From d0fa2d4247660a105a6013c69803494b57f72306 Mon Sep 17 00:00:00 2001
From: asuessenbach <asuessenbach@nvidia.com>
Date: Sat, 15 May 2021 23:26:51 +0200
Subject: [PATCH] Reorder member functions by features and extensions.

---
 VulkanHppGenerator.cpp |  3265 +--
 VulkanHppGenerator.hpp |   274 +-
 vulkan/vulkan.hpp      | 45460 ++++++++++++++++++++-------------------
 vulkan/vulkan_raii.hpp | 13487 ++++++------
 4 files changed, 31717 insertions(+), 30769 deletions(-)

diff --git a/VulkanHppGenerator.cpp b/VulkanHppGenerator.cpp
index 8dedbaa..3a478df 100644
--- a/VulkanHppGenerator.cpp
+++ b/VulkanHppGenerator.cpp
@@ -43,6 +43,9 @@ std::string      determineNoDiscard( bool multiSuccessCodes, bool multiErrorCode
 std::set<size_t> determineSingularParams( size_t                           returnParamIndex,
                                           std::map<size_t, size_t> const & vectorParamIndices );
 std::set<size_t> determineSkippedParams( size_t returnParamIndex, std::map<size_t, size_t> const & vectorParamIndices );
+std::vector<std::string> extractHandleCommands( std::vector<std::string> const & commands,
+                                                std::set<std::string> const &    handleCommands,
+                                                std::set<std::string> &          listedCommands );
 std::string findTag( std::set<std::string> const & tags, std::string const & name, std::string const & postfix = "" );
 std::map<std::string, std::string> getAttributes( tinyxml2::XMLElement const * element );
 template <typename ElementContainer>
@@ -335,6 +338,23 @@ std::set<size_t> determineSkippedParams( size_t returnParamIndex, std::map<size_
   return skippedParams;
 }
 
+std::vector<std::string> extractHandleCommands( std::vector<std::string> const & commands,
+                                                std::set<std::string> const &    handleCommands,
+                                                std::set<std::string> &          listedCommands )
+{
+  std::vector<std::string> extractedCommands;
+  for ( auto const & command : commands )
+  {
+    if ( ( handleCommands.find( command ) != handleCommands.end() ) &&
+         ( listedCommands.find( command ) == listedCommands.end() ) )
+    {
+      listedCommands.insert( command );
+      extractedCommands.push_back( command );
+    }
+  }
+  return extractedCommands;
+}
+
 std::string findTag( std::set<std::string> const & tags, std::string const & name, std::string const & postfix )
 {
   auto tagIt = std::find_if(
@@ -907,6 +927,8 @@ void VulkanHppGenerator::appendBitmasks( std::string & str ) const
       if ( !enter.empty() )
       {
         enter = "\n" + enter;
+        assert( endsWith( enter, "\n" ) );
+        enter.resize( enter.size() - strlen( "\n" ) );
       }
       str += enter + "\n  //=== " + extIt.second->first + " ===\n";
       for ( auto bitmaskIt : bitmaskIts )
@@ -1137,6 +1159,68 @@ void VulkanHppGenerator::appendCall( std::string &                    str,
   str += " )";
 }
 
+void VulkanHppGenerator::appendCommand( std::string &       str,
+                                        std::string const & command,
+                                        std::string const & handle ) const
+{
+  auto commandIt = m_commands.find( command );
+  assert( commandIt != m_commands.end() );
+
+  std::string strippedName = startLowerCase( stripPrefix( commandIt->first, "vk" ) );
+
+  str += "\n";
+  appendCommand( str, commandIt->first, commandIt->second, handle.empty() ? 0 : 1, true );
+
+  // special handling for destroy functions, filter out alias functions
+  std::string commandName = determineCommandName( commandIt->first, commandIt->second.params[0].type.type, m_tags );
+  if ( commandIt->second.alias.empty() &&
+       ( ( ( commandIt->first.substr( 2, 7 ) == "Destroy" ) && ( commandName != "destroy" ) ) ||
+         ( commandIt->first.substr( 2, 4 ) == "Free" ) ||
+         ( commandIt->first == "vkReleasePerformanceConfigurationINTEL" ) ) )
+  {
+    std::string destroyCommandString;
+    CommandData commandData = commandIt->second;
+    assert( ( 1 < commandData.params.size() ) && ( commandData.params[0].type.type == handle ) );
+    commandData.params[1].optional =
+      false;  // make sure, the object to destroy/free/release is not optional in the shortened version!
+
+    appendCommand( destroyCommandString, commandIt->first, commandData, handle.empty() ? 0 : 1, true );
+    std::string shortenedName;
+    if ( commandIt->first.substr( 2, 7 ) == "Destroy" )
+    {
+      shortenedName = "destroy";
+    }
+    else if ( commandIt->first.substr( 2, 4 ) == "Free" )
+    {
+      shortenedName = "free";
+    }
+    else
+    {
+      assert( commandIt->first == "vkReleasePerformanceConfigurationINTEL" );
+      shortenedName = "release";
+    }
+    size_t pos = destroyCommandString.find( commandName );
+    while ( pos != std::string::npos )
+    {
+      destroyCommandString.replace( pos, commandName.length(), shortenedName );
+      pos = destroyCommandString.find( commandName, pos );
+    }
+    // we need to remove the default argument for the first argument, to prevent ambiguities!
+    assert( 1 < commandIt->second.params.size() );
+    pos = destroyCommandString.find( commandIt->second.params[1].name );  // skip the standard version of the function
+    assert( pos != std::string::npos );
+    pos = destroyCommandString.find( commandIt->second.params[1].name,
+                                     pos + 1 );  // get the argument to destroy in the advanced version
+    assert( pos != std::string::npos );
+    pos = destroyCommandString.find( " VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT", pos );
+    if ( pos != std::string::npos )
+    {
+      destroyCommandString.erase( pos, strlen( " VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT" ) );
+    }
+    str += "\n" + destroyCommandString;
+  }
+}
+
 void VulkanHppGenerator::appendCommand( std::string &       str,
                                         std::string const & name,
                                         CommandData const & commandData,
@@ -1178,15 +1262,12 @@ void VulkanHppGenerator::appendCommandChained( std::string &
   assert( ( commandData.returnType == "VkResult" ) || ( commandData.returnType == "void" ) );
 
   std::string const functionTemplate = R"(
-${enter}${commandStandard}${newlineOnDefinition}
+${commandStandard}${newlineOnDefinition}
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
 ${commandEnhanced}${newlineOnDefinition}
 ${commandEnhancedChained}
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-${leave})";
-
-  std::string enter, leave;
-  std::tie( enter, leave ) = generateProtection( commandData.referencedIn );
+)";
 
   str += replaceWithMap(
     functionTemplate,
@@ -1201,8 +1282,6 @@ ${leave})";
             ? constructCommandVoidGetChain( name, commandData, initialSkipCount, definition, nonConstPointerIndex )
             : constructCommandResultGetChain( name, commandData, initialSkipCount, definition, nonConstPointerIndex ) },
         { "commandStandard", constructCommandStandard( name, commandData, initialSkipCount, definition ) },
-        { "enter", enter },
-        { "leave", leave },
         { "newlineOnDefinition", definition ? "\n" : "" } } ) );
 }
 
@@ -1441,16 +1520,13 @@ void VulkanHppGenerator::appendCommandSingular( std::string &
   assert( commandData.returnType == "VkResult" );
 
   std::string const functionTemplate = R"(
-${enter}${commandStandard}${newlineOnDefinition}
+${commandStandard}${newlineOnDefinition}
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
 ${commandEnhancedDeprecated}${newlineOnDefinition}
 ${commandEnhanced}${newlineOnDefinition}
 ${commandEnhancedSingular}
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-${leave})";
-
-  std::string enter, leave;
-  std::tie( enter, leave ) = generateProtection( commandData.referencedIn );
+)";
 
   str += replaceWithMap(
     functionTemplate,
@@ -1465,8 +1541,6 @@ ${leave})";
           constructCommandResultGetVectorOfVoidSingular(
             name, commandData, initialSkipCount, definition, vectorParamIndices, returnParamIndex ) },
         { "commandStandard", constructCommandStandard( name, commandData, initialSkipCount, definition ) },
-        { "enter", enter },
-        { "leave", leave },
         { "newlineOnDefinition", definition ? "\n" : "" } } ) );
 }
 
@@ -1477,18 +1551,14 @@ void VulkanHppGenerator::appendCommandStandard( std::string &       str,
                                                 bool                definition ) const
 {
   const std::string functionTemplate = R"(
-${enter}${commandStandard}
-${leave})";
-
-  std::string enter, leave;
-  std::tie( enter, leave ) = generateProtection( commandData.referencedIn );
+${commandStandard}
+)";
 
   str += replaceWithMap(
     functionTemplate,
-    std::map<std::string, std::string>(
-      { { "commandStandard", constructCommandStandard( name, commandData, initialSkipCount, definition ) },
-        { "enter", enter },
-        { "leave", leave } } ) );
+    std::map<std::string, std::string>( {
+      { "commandStandard", constructCommandStandard( name, commandData, initialSkipCount, definition ) },
+    } ) );
 }
 
 void VulkanHppGenerator::appendCommandStandardAndEnhanced(
@@ -1501,14 +1571,11 @@ void VulkanHppGenerator::appendCommandStandardAndEnhanced(
   std::vector<size_t> const &      nonConstPointerParamIndices ) const
 {
   const std::string functionTemplate = R"(
-${enter}${commandStandard}${newlineOnDefinition}
+${commandStandard}${newlineOnDefinition}
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
 ${commandEnhanced}
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-${leave})";
-
-  std::string enter, leave;
-  std::tie( enter, leave ) = generateProtection( commandData.referencedIn );
+)";
 
   std::string commandEnhanced;
   switch ( nonConstPointerParamIndices.size() )
@@ -1579,8 +1646,6 @@ ${leave})";
     std::map<std::string, std::string>(
       { { "commandEnhanced", commandEnhanced },
         { "commandStandard", constructCommandStandard( name, commandData, initialSkipCount, definition ) },
-        { "enter", enter },
-        { "leave", leave },
         { "newlineOnDefinition", definition ? "\n" : "" } } ) );
 }
 
@@ -1599,16 +1664,13 @@ void VulkanHppGenerator::appendCommandStandardEnhancedDeprecatedAllocator(
   assert( commandData.returnType == "VkResult" );
 
   const std::string functionTemplate = R"(
-${enter}${commandStandard}${newlineOnDefinition}
+${commandStandard}${newlineOnDefinition}
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
 ${commandEnhancedDeprecated}${newlineOnDefinition}
 ${commandEnhanced}${newlineOnDefinition}
 ${commandEnhancedWithAllocator}
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-${leave})";
-
-  std::string enter, leave;
-  std::tie( enter, leave ) = generateProtection( commandData.referencedIn );
+)";
 
   str += replaceWithMap(
     functionTemplate,
@@ -1623,8 +1685,6 @@ ${leave})";
           constructCommandResultGetVectorAndValue(
             name, commandData, initialSkipCount, definition, vectorParamIndices, nonConstPointerParamIndices, true ) },
         { "commandStandard", constructCommandStandard( name, commandData, initialSkipCount, definition ) },
-        { "enter", enter },
-        { "leave", leave },
         { "newlineOnDefinition", definition ? "\n" : "" } } ) );
 }
 
@@ -1637,24 +1697,19 @@ void VulkanHppGenerator::appendCommandStandardOrEnhanced( std::string &       st
   assert( commandData.returnType == "VkResult" );
 
   const std::string functionTemplate = R"(
-${enter}#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
 ${commandStandard}
 #else
 ${commandEnhanced}
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-${leave}
 )";
 
-  std::string enter, leave;
-  std::tie( enter, leave ) = generateProtection( commandData.referencedIn );
-
   str += replaceWithMap(
     functionTemplate,
-    std::map<std::string, std::string>(
-      { { "commandEnhanced", constructCommandResult( name, commandData, initialSkipCount, definition, {} ) },
-        { "commandStandard", constructCommandStandard( name, commandData, initialSkipCount, definition ) },
-        { "enter", enter },
-        { "leave", leave } } ) );
+    std::map<std::string, std::string>( {
+      { "commandEnhanced", constructCommandResult( name, commandData, initialSkipCount, definition, {} ) },
+      { "commandStandard", constructCommandStandard( name, commandData, initialSkipCount, definition ) },
+    } ) );
 }
 
 void VulkanHppGenerator::appendCommandUnique( std::string &       str,
@@ -1665,17 +1720,14 @@ void VulkanHppGenerator::appendCommandUnique( std::string &       str,
                                               bool                definition ) const
 {
   std::string const functionTemplate = R"(
-${enter}${commandStandard}${newlineOnDefinition}
+${commandStandard}${newlineOnDefinition}
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
 ${commandEnhanced}${newlineOnDefinition}
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
 ${commandEnhancedUnique}
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-${leave})";
-
-  std::string enter, leave;
-  std::tie( enter, leave ) = generateProtection( commandData.referencedIn );
+)";
 
   str += replaceWithMap(
     functionTemplate,
@@ -1686,8 +1738,6 @@ ${leave})";
           constructCommandResultGetHandleUnique(
             name, commandData, initialSkipCount, definition, nonConstPointerIndex ) },
         { "commandStandard", constructCommandStandard( name, commandData, initialSkipCount, definition ) },
-        { "enter", enter },
-        { "leave", leave },
         { "newlineOnDefinition", definition ? "\n" : "" } } ) );
 }
 
@@ -1746,16 +1796,13 @@ void VulkanHppGenerator::appendCommandVector( std::string &
 {
   assert( ( commandData.returnType == "VkResult" ) || ( commandData.returnType == "void" ) );
 
-  std::string enter, leave;
-  std::tie( enter, leave ) = generateProtection( commandData.referencedIn );
-
   const std::string functionTemplate = R"(
-${enter}${commandStandard}${newlineOnDefinition}
+${commandStandard}${newlineOnDefinition}
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
 ${commandEnhanced}${newlineOnDefinition}
 ${commandEnhancedWithAllocators}
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-${leave})";
+)";
 
   str += replaceWithMap(
     functionTemplate,
@@ -1772,8 +1819,6 @@ ${leave})";
             : constructCommandVoidEnumerate(
                 name, commandData, initialSkipCount, definition, vectorParamIndex, returnParamIndices, true ) },
         { "commandStandard", constructCommandStandard( name, commandData, initialSkipCount, definition ) },
-        { "enter", enter },
-        { "leave", leave },
         { "newlineOnDefinition", definition ? "\n" : "" } } ) );
 }
 
@@ -1789,17 +1834,14 @@ void VulkanHppGenerator::appendCommandVectorChained( std::string &
   assert( vectorParamIndices.size() == 1 );
 
   std::string const functionTemplate = R"(
-${enter}${commandStandard}${newlineOnDefinition}
+${commandStandard}${newlineOnDefinition}
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
 ${commandEnhanced}${newlineOnDefinition}
 ${commandEnhancedWithAllocator}${newlineOnDefinition}
 ${commandEnhancedChained}${newlineOnDefinition}
 ${commandEnhancedChainedWithAllocator}
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-${leave})";
-
-  std::string enter, leave;
-  std::tie( enter, leave ) = generateProtection( commandData.referencedIn );
+)";
 
   str += replaceWithMap(
     functionTemplate,
@@ -1854,8 +1896,6 @@ ${leave})";
                                              returnParamIndices,
                                              true ) },
         { "commandStandard", constructCommandStandard( name, commandData, initialSkipCount, definition ) },
-        { "enter", enter },
-        { "leave", leave },
         { "newlineOnDefinition", definition ? "\n" : "" } } ) );
 }
 
@@ -1870,10 +1910,6 @@ void VulkanHppGenerator::appendCommandVectorDeprecated( std::string &
   assert( commandData.returnType == "VkResult" );
   assert( vectorParamIndices.size() == 2 );
 
-  std::string enter, leave;
-  std::tie( enter, leave ) = generateProtection( commandData.referencedIn );
-  assert( enter.empty() );
-
   const std::string functionTemplate = R"(
 ${commandStandard}${newlineOnDefinition}
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
@@ -1914,16 +1950,13 @@ void VulkanHppGenerator::appendCommandVectorSingular( std::string &
   assert( commandData.returnType == "VkResult" );
 
   std::string const functionTemplate = R"(
-${enter}${commandStandard}${newlineOnDefinition}
+${commandStandard}${newlineOnDefinition}
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
 ${commandEnhanced}${newlineOnDefinition}
 ${commandEnhancedWithAllocators}${newlineOnDefinition}
 ${commandEnhancedSingular}${newlineOnDefinition}
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-${leave})";
-
-  std::string enter, leave;
-  std::tie( enter, leave ) = generateProtection( commandData.referencedIn );
+)";
 
   str += replaceWithMap(
     functionTemplate,
@@ -1938,8 +1971,6 @@ ${leave})";
           constructCommandResultGetVector(
             name, commandData, initialSkipCount, definition, vectorParamIndices, returnParamIndex, true ) },
         { "commandStandard", constructCommandStandard( name, commandData, initialSkipCount, definition ) },
-        { "enter", enter },
-        { "leave", leave },
         { "newlineOnDefinition", definition ? "\n" : "" } } ) );
 }
 
@@ -1954,7 +1985,7 @@ void VulkanHppGenerator::appendCommandVectorSingularUnique( std::string &
   assert( commandData.returnType == "VkResult" );
 
   std::string const functionTemplate = R"(
-${enter}${commandStandard}${newlineOnDefinition}
+${commandStandard}${newlineOnDefinition}
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
 ${commandEnhanced}${newlineOnDefinition}
 ${commandEnhancedWithAllocators}${newlineOnDefinition}
@@ -1965,10 +1996,7 @@ ${commandEnhancedUniqueWithAllocators}${newlineOnDefinition}
 ${commandEnhancedUniqueSingular}
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-${leave})";
-
-  std::string enter, leave;
-  std::tie( enter, leave ) = generateProtection( commandData.referencedIn );
+)";
 
   str += replaceWithMap(
     functionTemplate,
@@ -1992,8 +2020,6 @@ ${leave})";
           constructCommandResultGetVectorOfHandles(
             name, commandData, initialSkipCount, definition, vectorParamIndices, returnParamIndex, true ) },
         { "commandStandard", constructCommandStandard( name, commandData, initialSkipCount, definition ) },
-        { "enter", enter },
-        { "leave", leave },
         { "newlineOnDefinition", definition ? "\n" : "" } } ) );
 }
 
@@ -2008,7 +2034,7 @@ void VulkanHppGenerator::appendCommandVectorUnique( std::string &
   assert( commandData.returnType == "VkResult" );
 
   std::string const functionTemplate = R"(
-${enter}${commandStandard}${newlineOnDefinition}
+${commandStandard}${newlineOnDefinition}
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
 ${commandEnhanced}${newlineOnDefinition}
 ${commandEnhancedWithAllocators}${newlineOnDefinition}
@@ -2017,10 +2043,7 @@ ${commandEnhancedUnique}${newlineOnDefinition}
 ${commandEnhancedUniqueWithAllocators}
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-${leave})";
-
-  std::string enter, leave;
-  std::tie( enter, leave ) = generateProtection( commandData.referencedIn );
+)";
 
   str += replaceWithMap(
     functionTemplate,
@@ -2038,8 +2061,6 @@ ${leave})";
           constructCommandResultGetVectorOfHandles(
             name, commandData, initialSkipCount, definition, vectorParamIndices, returnParamIndex, true ) },
         { "commandStandard", constructCommandStandard( name, commandData, initialSkipCount, definition ) },
-        { "enter", enter },
-        { "leave", leave },
         { "newlineOnDefinition", definition ? "\n" : "" } } ) );
 }
 
@@ -2288,6 +2309,8 @@ void VulkanHppGenerator::appendDispatchLoaderStatic( std::string & str )
       if ( !enter.empty() )
       {
         enter = "\n" + enter;
+        assert( endsWith( enter, "\n" ) );
+        enter.resize( enter.size() - strlen( "\n" ) );
       }
       str += enter + "\n    //=== " + extIt.second->first + " ===\n";
       for ( auto const & commandName : extIt.second->second.commands )
@@ -2519,6 +2542,60 @@ bool VulkanHppGenerator::appendCommandVoid2Return( std::string &               s
   return appendedFunction;
 }
 
+void VulkanHppGenerator::appendDestroyCommand( std::string &       str,
+                                               std::string const & name,
+                                               CommandData const & commandData,
+                                               std::string const & handleName ) const
+{
+  // special handling for destroy functions, filter out alias functions
+  std::string commandName = determineCommandName( name, commandData.params[0].type.type, m_tags );
+  if ( commandData.alias.empty() &&
+       ( ( ( name.substr( 2, 7 ) == "Destroy" ) && ( commandName != "destroy" ) ) ||
+         ( name.substr( 2, 4 ) == "Free" ) || ( name == "vkReleasePerformanceConfigurationINTEL" ) ) )
+  {
+    assert( ( 1 < commandData.params.size() ) && ( commandData.params[0].type.type == handleName ) );
+    // make sure, the object to destroy/free/release is not optional in the shortened version!
+    CommandData localCommandData        = commandData;
+    localCommandData.params[1].optional = false;
+
+    std::string destroyCommandString;
+    appendCommand( destroyCommandString, name, localCommandData, 1, false );
+    std::string shortenedName;
+    if ( name.substr( 2, 7 ) == "Destroy" )
+    {
+      shortenedName = "destroy";
+    }
+    else if ( name.substr( 2, 4 ) == "Free" )
+    {
+      shortenedName = "free";
+    }
+    else
+    {
+      assert( name == "vkReleasePerformanceConfigurationINTEL" );
+      shortenedName = "release";
+    }
+    size_t pos = destroyCommandString.find( commandName );
+    while ( pos != std::string::npos )
+    {
+      destroyCommandString.replace( pos, commandName.length(), shortenedName );
+      pos = destroyCommandString.find( commandName, pos );
+    }
+    // we need to remove the default argument for the first argument, to prevent ambiguities!
+    assert( 1 < localCommandData.params.size() );
+    pos = destroyCommandString.find( localCommandData.params[1].name );  // skip the standard version of the function
+    assert( pos != std::string::npos );
+    pos = destroyCommandString.find( localCommandData.params[1].name,
+                                     pos + 1 );  // get the argument to destroy in the advanced version
+    assert( pos != std::string::npos );
+    pos = destroyCommandString.find( " VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT", pos );
+    if ( pos != std::string::npos )
+    {
+      destroyCommandString.erase( pos, strlen( " VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT" ) );
+    }
+    str += "\n" + destroyCommandString;
+  }
+}
+
 void VulkanHppGenerator::appendDispatchLoaderDynamicCommand( std::string &       str,
                                                              std::string &       emptyFunctions,
                                                              std::string &       deviceFunctions,
@@ -2710,6 +2787,8 @@ void VulkanHppGenerator::appendEnums( std::string & str ) const
       if ( !enter.empty() )
       {
         enter = "\n" + enter;
+        assert( endsWith( enter, "\n" ) );
+        enter.resize( enter.size() - strlen( "\n" ) );
       }
       str += enter + "\n  //=== " + extIt.second->first + " ===\n";
       for ( auto enumIt : enumIts )
@@ -3061,27 +3140,47 @@ void VulkanHppGenerator::appendHandle( std::string & str, std::pair<std::string,
     }
   }
 
+  // list the commands of this handle
   if ( handleData.first.empty() )
   {
-    for ( auto const & command : handleData.second.commands )
+    // first, the free functions, not bound to any handle
+    std::set<std::string> listedCommands;  // some commands are listed with more than one extension !
+    for ( auto const & feature : m_features )
     {
-      auto commandIt = m_commands.find( command );
-      assert( commandIt != m_commands.end() );
-      if ( commandIt->first == "vkCreateInstance" )
+      std::vector<std::string> commands =
+        extractHandleCommands( feature.second.commands, handleData.second.commands, listedCommands );
+      if ( !commands.empty() )
       {
-        // special handling for createInstance, as we need to explicitly place the forward declarations and the
-        // deleter classes here
+        str += "\n  //=== " + feature.first + " ===\n";
+        for ( auto const & command : commands )
+        {
+          auto commandIt = m_commands.find( command );
+          assert( commandIt != m_commands.end() );
+          if ( commandIt->first == "vkCreateInstance" )
+          {
+            // special handling for createInstance, as we need to explicitly place the forward declarations and the
+            // deleter classes here
 #if !defined( NDEBUG )
-        auto handleIt = m_handles.find( "" );
-        assert( ( handleIt != m_handles.end() ) && ( handleIt->second.childrenHandles.size() == 2 ) );
-        assert( handleIt->second.childrenHandles.find( "VkInstance" ) != handleIt->second.childrenHandles.end() );
+            auto handleIt = m_handles.find( "" );
+            assert( ( handleIt != m_handles.end() ) && ( handleIt->second.childrenHandles.size() == 2 ) );
+            assert( handleIt->second.childrenHandles.find( "VkInstance" ) != handleIt->second.childrenHandles.end() );
 #endif
 
-        appendUniqueTypes( str, "", { "VkInstance" } );
+            appendUniqueTypes( str, "", { "VkInstance" } );
+          }
+          str += "\n";
+
+          appendCommand( str, commandIt->first, commandIt->second, 0, false );
+        }
       }
-      str += "\n";
-      appendCommand( str, commandIt->first, commandIt->second, 0, false );
     }
+#if !defined( NDEBUG )
+    for ( auto const & extIt : m_extensionsByNumber )
+    {
+      assert(
+        extractHandleCommands( extIt.second->second.commands, handleData.second.commands, listedCommands ).empty() );
+    }
+#endif
   }
   else
   {
@@ -3096,65 +3195,56 @@ void VulkanHppGenerator::appendHandle( std::string & str, std::pair<std::string,
       appendUniqueTypes( str, "", { "VkDevice" } );
     }
 
-    std::string commands;
     // list all the commands that are mapped to members of this class
-    for ( auto const & command : handleData.second.commands )
+    std::string           commands;
+    std::set<std::string> listedCommands;  // some commands are listed with more than one extension!
+    for ( auto const & feature : m_features )
     {
-      auto commandIt = m_commands.find( command );
-      assert( commandIt != m_commands.end() );
-
-      std::string commandString;
-      std::string commandName = determineCommandName( commandIt->first, commandIt->second.params[0].type.type, m_tags );
-      commands += "\n";
-      appendCommand( commands, commandIt->first, commandIt->second, 1, false );
-
-      // special handling for destroy functions, filter out alias functions
-      if ( commandIt->second.alias.empty() &&
-           ( ( ( commandIt->first.substr( 2, 7 ) == "Destroy" ) && ( commandName != "destroy" ) ) ||
-             ( commandIt->first.substr( 2, 4 ) == "Free" ) ||
-             ( commandIt->first == "vkReleasePerformanceConfigurationINTEL" ) ) )
+      std::vector<std::string> commandNames =
+        extractHandleCommands( feature.second.commands, handleData.second.commands, listedCommands );
+      if ( !commandNames.empty() )
       {
-        std::string destroyCommandString;
-        CommandData commandData = commandIt->second;
-        assert( ( 1 < commandData.params.size() ) && ( commandData.params[0].type.type == handleData.first ) );
-        commandData.params[1].optional =
-          false;  // make sure, the object to destroy/free/release is not optional in the shortened version!
+        commands += "\n  //=== " + feature.first + " ===\n";
+        for ( auto const & command : commandNames )
+        {
+          auto commandIt = m_commands.find( command );
+          assert( commandIt != m_commands.end() );
 
-        appendCommand( destroyCommandString, commandIt->first, commandData, 1, false );
-        std::string shortenedName;
-        if ( commandIt->first.substr( 2, 7 ) == "Destroy" )
-        {
-          shortenedName = "destroy";
+          commands += "\n";
+          appendCommand( commands, commandIt->first, commandIt->second, 1, false );
+          appendDestroyCommand( commands, commandIt->first, commandIt->second, handleData.first );
         }
-        else if ( commandIt->first.substr( 2, 4 ) == "Free" )
+      }
+    }
+    for ( auto const & extIt : m_extensionsByNumber )
+    {
+      std::vector<std::string> commandNames =
+        extractHandleCommands( extIt.second->second.commands, handleData.second.commands, listedCommands );
+      if ( !commandNames.empty() )
+      {
+        std::string enter, leave;
+        std::tie( enter, leave ) = generateProtection( extIt.second->first );
+        if ( !enter.empty() )
         {
-          shortenedName = "free";
+          enter = "\n" + enter;
+          assert( endsWith( enter, "\n" ) );
+          enter.resize( enter.size() - strlen( "\n" ) );
         }
-        else
+
+        commands += enter + "\n  //=== " + extIt.second->first + " ===\n";
+        for ( auto const & command : commandNames )
         {
-          assert( commandIt->first == "vkReleasePerformanceConfigurationINTEL" );
-          shortenedName = "release";
+          auto commandIt = m_commands.find( command );
+          assert( commandIt != m_commands.end() );
+
+          std::string commandString;
+          std::string commandName =
+            determineCommandName( commandIt->first, commandIt->second.params[0].type.type, m_tags );
+          commands += "\n";
+          appendCommand( commands, commandIt->first, commandIt->second, 1, false );
+          appendDestroyCommand( commands, commandIt->first, commandIt->second, handleData.first );
         }
-        size_t pos = destroyCommandString.find( commandName );
-        while ( pos != std::string::npos )
-        {
-          destroyCommandString.replace( pos, commandName.length(), shortenedName );
-          pos = destroyCommandString.find( commandName, pos );
-        }
-        // we need to remove the default argument for the first argument, to prevent ambiguities!
-        assert( 1 < commandIt->second.params.size() );
-        pos =
-          destroyCommandString.find( commandIt->second.params[1].name );  // skip the standard version of the function
-        assert( pos != std::string::npos );
-        pos = destroyCommandString.find( commandIt->second.params[1].name,
-                                         pos + 1 );  // get the argument to destroy in the advanced version
-        assert( pos != std::string::npos );
-        pos = destroyCommandString.find( " VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT", pos );
-        if ( pos != std::string::npos )
-        {
-          destroyCommandString.erase( pos, strlen( " VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT" ) );
-        }
-        commands += "\n" + destroyCommandString;
+        commands += leave;
       }
     }
 
@@ -3304,6 +3394,7 @@ ${CppTypeFromDebugReportObjectTypeEXT}
 
 void VulkanHppGenerator::appendHandles( std::string & str )
 {
+  // Note reordering structs or handles by features and extensions is not possible!
   for ( auto const & handle : m_handles )
   {
     if ( m_listedTypes.find( handle.first ) == m_listedTypes.end() )
@@ -3317,68 +3408,50 @@ void VulkanHppGenerator::appendHandles( std::string & str )
 
 void VulkanHppGenerator::appendHandlesCommandDefinitions( std::string & str ) const
 {
-  for ( auto const & handle : m_handles )
+  str += R"(
+  //===========================
+  //=== COMMAND Definitions ===
+  //===========================
+)";
+
+  std::set<std::string> listedCommands;  // some commands are listed with more than one extension!
+  for ( auto const & feature : m_features )
   {
-    // finally the commands, that are member functions of this handle
-    for ( auto const & command : handle.second.commands )
+    str += "\n  //=== " + feature.first + " ===\n";
+    for ( auto const & command : feature.second.commands )
     {
+      assert( listedCommands.find( command ) == listedCommands.end() );
+      listedCommands.insert( command );
+
       auto commandIt = m_commands.find( command );
       assert( commandIt != m_commands.end() );
-
-      std::string strippedName = startLowerCase( stripPrefix( commandIt->first, "vk" ) );
-
-      str += "\n";
-      appendCommand( str, commandIt->first, commandIt->second, handle.first.empty() ? 0 : 1, true );
-
-      // special handling for destroy functions, filter out alias functions
-      std::string commandName = determineCommandName( commandIt->first, commandIt->second.params[0].type.type, m_tags );
-      if ( commandIt->second.alias.empty() &&
-           ( ( ( commandIt->first.substr( 2, 7 ) == "Destroy" ) && ( commandName != "destroy" ) ) ||
-             ( commandIt->first.substr( 2, 4 ) == "Free" ) ||
-             ( commandIt->first == "vkReleasePerformanceConfigurationINTEL" ) ) )
+      appendCommand( str, command, commandIt->second.handle );
+    }
+  }
+  for ( auto const & extIt : m_extensionsByNumber )
+  {
+    if ( !extIt.second->second.commands.empty() )
+    {
+      std::string enter, leave;
+      std::tie( enter, leave ) = generateProtection( extIt.second->first );
+      if ( !enter.empty() )
       {
-        std::string destroyCommandString;
-        CommandData commandData = commandIt->second;
-        assert( ( 1 < commandData.params.size() ) && ( commandData.params[0].type.type == handle.first ) );
-        commandData.params[1].optional =
-          false;  // make sure, the object to destroy/free/release is not optional in the shortened version!
-
-        appendCommand( destroyCommandString, commandIt->first, commandData, handle.first.empty() ? 0 : 1, true );
-        std::string shortenedName;
-        if ( commandIt->first.substr( 2, 7 ) == "Destroy" )
-        {
-          shortenedName = "destroy";
-        }
-        else if ( commandIt->first.substr( 2, 4 ) == "Free" )
-        {
-          shortenedName = "free";
-        }
-        else
-        {
-          assert( commandIt->first == "vkReleasePerformanceConfigurationINTEL" );
-          shortenedName = "release";
-        }
-        size_t pos = destroyCommandString.find( commandName );
-        while ( pos != std::string::npos )
-        {
-          destroyCommandString.replace( pos, commandName.length(), shortenedName );
-          pos = destroyCommandString.find( commandName, pos );
-        }
-        // we need to remove the default argument for the first argument, to prevent ambiguities!
-        assert( 1 < commandIt->second.params.size() );
-        pos =
-          destroyCommandString.find( commandIt->second.params[1].name );  // skip the standard version of the function
-        assert( pos != std::string::npos );
-        pos = destroyCommandString.find( commandIt->second.params[1].name,
-                                         pos + 1 );  // get the argument to destroy in the advanced version
-        assert( pos != std::string::npos );
-        pos = destroyCommandString.find( " VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT", pos );
-        if ( pos != std::string::npos )
-        {
-          destroyCommandString.erase( pos, strlen( " VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT" ) );
-        }
-        str += "\n" + destroyCommandString;
+        enter = "\n" + enter;
+        assert( endsWith( enter, "\n" ) );
+        enter.resize( enter.size() - strlen( "\n" ) );
       }
+      str += enter + "\n  //=== " + extIt.second->first + " ===\n";
+      for ( auto const & command : extIt.second->second.commands )
+      {
+        if ( listedCommands.find( command ) == listedCommands.end() )
+        {
+          listedCommands.insert( command );
+          auto commandIt = m_commands.find( command );
+          assert( commandIt != m_commands.end() );
+          appendCommand( str, command, commandIt->second.handle );
+        }
+      }
+      str += leave;
     }
   }
 }
@@ -3409,6 +3482,62 @@ void VulkanHppGenerator::appendHashStructures( std::string & str ) const
   }
 }
 
+void VulkanHppGenerator::appendRAIICommands( std::string & str, std::set<std::string> const & specialFunctions ) const
+{
+  str += R"(
+  //===========================
+  //=== COMMAND Definitions ===
+  //===========================
+)";
+
+  std::set<std::string> listedCommands;  // some commands are listed with more than one extension!
+  for ( auto const & feature : m_features )
+  {
+    str += "\n  //=== " + feature.first + " ===\n";
+    for ( auto const & command : feature.second.commands )
+    {
+      if ( specialFunctions.find( command ) == specialFunctions.end() )
+      {
+        assert( listedCommands.find( command ) == listedCommands.end() );
+        listedCommands.insert( command );
+        str +=
+          constructRAIIHandleMemberFunction( command, determineInitialSkipCount( command ), specialFunctions, true );
+      }
+    }
+  }
+  for ( auto const & extIt : m_extensionsByNumber )
+  {
+    std::vector<std::string> commands;
+    for ( auto const & command : extIt.second->second.commands )
+    {
+      if ( ( specialFunctions.find( command ) == specialFunctions.end() ) &&
+           ( listedCommands.find( command ) == listedCommands.end() ) )
+      {
+        listedCommands.insert( command );
+        commands.push_back( command );
+      }
+    }
+    if ( !commands.empty() )
+    {
+      std::string enter, leave;
+      std::tie( enter, leave ) = generateProtection( extIt.second->first );
+      if ( !enter.empty() )
+      {
+        enter = "\n" + enter;
+        assert( endsWith( enter, "\n" ) );
+        enter.resize( enter.size() - strlen( "\n" ) );
+      }
+      str += enter + "\n  //=== " + extIt.second->first + " ===\n";
+      for ( auto const & command : commands )
+      {
+        str +=
+          constructRAIIHandleMemberFunction( command, determineInitialSkipCount( command ), specialFunctions, true );
+      }
+      str += leave;
+    }
+  }
+}
+
 void VulkanHppGenerator::appendRAIIDispatchers( std::string & str ) const
 {
   std::string contextInitializerList, deviceInitAssignments, instanceInitAssignments;
@@ -3523,39 +3652,17 @@ ${members}
                          { { "initAssignments", deviceInitAssignments }, { "members", deviceMembers } } );
 }
 
-void VulkanHppGenerator::appendRAIIHandles( std::string & str, std::string & commandDefinitions )
+void VulkanHppGenerator::appendRAIIHandles( std::string & str, std::set<std::string> const & specialFunctions ) const
 {
-  // Enum -> Type translations are always able to occur.
   str += "\n";
 
-  // filtering out functions that are not usefull on this level of abstraction (like vkGetInstanceProcAddr)
-  // and all the construction and destruction functions, as they are used differently
-
-  std::set<std::string> specialFunctions;
-  for ( auto & handle : m_handles )
-  {
-    if ( !handle.first.empty() )
-    {
-      handle.second.destructorIt = determineRAIIHandleDestructor( handle.first );
-      if ( handle.second.destructorIt != m_commands.end() )
-      {
-        specialFunctions.insert( handle.second.destructorIt->first );
-      }
-      handle.second.constructorIts =
-        determineRAIIHandleConstructors( handle.first, handle.second.destructorIt, specialFunctions );
-    }
-  }
-
-  distributeSecondLevelCommands( specialFunctions );
-  renameFunctionParameters();
-
   std::set<std::string> listedHandles;
   auto                  handleIt = m_handles.begin();
   assert( handleIt->first.empty() );
-  appendRAIIHandleContext( str, commandDefinitions, *handleIt, specialFunctions );
+  appendRAIIHandleContext( str, *handleIt, specialFunctions );
   for ( ++handleIt; handleIt != m_handles.end(); ++handleIt )
   {
-    appendRAIIHandle( str, commandDefinitions, *handleIt, listedHandles, specialFunctions );
+    appendRAIIHandle( str, *handleIt, listedHandles, specialFunctions );
   }
 }
 
@@ -3594,14 +3701,13 @@ ${leave})";
 }
 
 void VulkanHppGenerator::appendRAIIHandle( std::string &                              str,
-                                           std::string &                              commandDefinitions,
                                            std::pair<std::string, HandleData> const & handle,
                                            std::set<std::string> &                    listedHandles,
                                            std::set<std::string> const &              specialFunctions ) const
 {
   if ( listedHandles.find( handle.first ) == listedHandles.end() )
   {
-    rescheduleRAIIHandle( str, commandDefinitions, handle, listedHandles, specialFunctions );
+    rescheduleRAIIHandle( str, handle, listedHandles, specialFunctions );
 
     std::string enter, leave;
     std::tie( enter, leave ) = generateProtection( handle.first, !handle.second.alias.empty() );
@@ -3621,9 +3727,7 @@ void VulkanHppGenerator::appendRAIIHandle( std::string &
     std::tie( getConstructorSuccessCode, memberVariables, moveConstructorInitializerList, moveAssignmentInstructions ) =
       constructRAIIHandleDetails( handle, destructorCall );
 
-    std::string declarations, definitions;
-    std::tie( declarations, definitions ) = constructRAIIHandleMemberFunctions( handle, specialFunctions );
-    commandDefinitions += definitions;
+    std::string declarations = constructRAIIHandleMemberFunctionDeclarations( handle, specialFunctions );
 
     assert( !handle.second.objTypeEnum.empty() );
     auto enumIt = m_enums.find( "VkObjectType" );
@@ -3648,7 +3752,8 @@ void VulkanHppGenerator::appendRAIIHandle( std::string &
         ? "VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher"
         : "VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher";
 
-    const std::string handleTemplate = R"(${enter}  class ${handleType}
+    const std::string handleTemplate = R"(
+${enter}  class ${handleType}
   {
   public:
     using CType = Vk${handleType};
@@ -3691,7 +3796,6 @@ ${getConstructorSuccessCode}
   private:
     ${memberVariables}
   };
-
 ${leave})";
 
     str += replaceWithMap(
@@ -3741,12 +3845,9 @@ ${leave}
 }
 
 void VulkanHppGenerator::appendRAIIHandleContext( std::string &                              str,
-                                                  std::string &                              commandDefinitions,
                                                   std::pair<std::string, HandleData> const & handle,
                                                   std::set<std::string> const &              specialFunctions ) const
 {
-  assert( commandDefinitions.empty() );
-
   const std::string contextTemplate = R"(
   class Context
   {
@@ -3787,10 +3888,9 @@ ${memberFunctionDeclarations}
 
 )";
 
-  std::string declarations;
-  std::tie( declarations, commandDefinitions ) = constructRAIIHandleMemberFunctions( handle, specialFunctions );
-
-  str += replaceWithMap( contextTemplate, { { "memberFunctionDeclarations", declarations } } );
+  str += replaceWithMap(
+    contextTemplate,
+    { { "memberFunctionDeclarations", constructRAIIHandleMemberFunctionDeclarations( handle, specialFunctions ) } } );
 }
 
 std::pair<std::string, std::string>
@@ -7676,28 +7776,55 @@ std::tuple<std::string, std::string, std::string, std::string>
     getConstructorSuccessCode, memberVariables, moveConstructorInitializerList, moveAssignmentInstructions );
 }
 
-std::pair<std::string, std::string> VulkanHppGenerator::constructRAIIHandleMemberFunctionResultEnumerate(
+std::string VulkanHppGenerator::constructRAIIHandleMemberFunction( std::string const &           command,
+                                                                   size_t                        initialSkipCount,
+                                                                   std::set<std::string> const & specialFunctions,
+                                                                   bool                          definition ) const
+{
+  std::string function;
+  if ( specialFunctions.find( command ) == specialFunctions.end() )
+  {
+    auto commandIt = m_commands.find( command );
+    assert( commandIt != m_commands.end() );
+
+    if ( commandIt->second.returnType == "VkResult" )
+    {
+      function = constructRAIIHandleMemberFunctionResult( commandIt, initialSkipCount, definition );
+    }
+    else
+    {
+      assert( commandIt->second.successCodes.empty() && commandIt->second.errorCodes.empty() );
+      if ( commandIt->second.returnType == "void" )
+      {
+        function = constructRAIIHandleMemberFunctionVoid( commandIt, initialSkipCount, definition );
+      }
+      else
+      {
+        function = constructRAIIHandleMemberFunctionValue( commandIt, initialSkipCount, definition );
+      }
+    }
+
+    if ( function.empty() )
+    {
+      throw std::runtime_error( "Never encountered a function like <" + commandIt->first + "> !" );
+    }
+  }
+  return function;
+}
+
+std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionResultEnumerate(
   std::map<std::string, CommandData>::const_iterator commandIt,
   size_t                                             initialSkipCount,
   std::map<size_t, size_t> const &                   vectorParamIndices,
-  std::vector<size_t> const &                        nonConstPointerParamIndices ) const
+  std::vector<size_t> const &                        nonConstPointerParamIndices,
+  bool                                               definition ) const
 {
   std::set<size_t> skippedParameters = determineSkippedParams(
     commandIt->second.params, initialSkipCount, vectorParamIndices, nonConstPointerParamIndices, false );
-  std::string argumentListDeclaration =
-    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, false, false, false, false );
-  std::string argumentListDefinition =
-    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, true, false, false, false );
+  std::string argumentList =
+    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, definition, false, false, false );
   std::string commandName = determineCommandName(
     commandIt->first, initialSkipCount ? commandIt->second.params[initialSkipCount - 1].type.type : "", m_tags );
-  std::string counterName =
-    startLowerCase( stripPrefix( commandIt->second.params[vectorParamIndices.begin()->second].name, "p" ) );
-  std::string enter, leave;
-  std::tie( enter, leave )       = generateProtection( commandIt->second.referencedIn );
-  std::string firstCallArguments = constructCallArgumentsEnhanced(
-    commandIt->second.params, initialSkipCount, true, {}, nonConstPointerParamIndices, true );
-  std::string secondCallArguments = constructCallArgumentsEnhanced(
-    commandIt->second.params, initialSkipCount, false, {}, nonConstPointerParamIndices, true );
   std::string vectorElementType = commandIt->second.params[vectorParamIndices.begin()->first].type.type;
   if ( !isHandleType( vectorElementType ) )
   {
@@ -7707,26 +7834,12 @@ std::pair<std::string, std::string> VulkanHppGenerator::constructRAIIHandleMembe
         ? "uint8_t"
         : stripPostfix( commandIt->second.params[vectorParamIndices.begin()->first].type.compose(), "*" );
   }
-  std::string vectorName =
-    startLowerCase( stripPrefix( commandIt->second.params[vectorParamIndices.begin()->first].name, "p" ) );
 
-  std::string const declarationTemplate =
-    R"(
-${enter}    VULKAN_HPP_NODISCARD std::vector<${vectorElementType}> ${commandName}( ${argumentList} ) const;
-${leave})";
-
-  std::string declaration = replaceWithMap( declarationTemplate,
-                                            {
-                                              { "argumentList", argumentListDeclaration },
-                                              { "commandName", commandName },
-                                              { "enter", enter },
-                                              { "leave", leave },
-                                              { "vectorElementType", vectorElementType },
-                                            } );
-
-  const std::string definitionTemplate =
-    R"(
-${enter}  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<${vectorElementType}> ${className}::${commandName}( ${argumentList} ) const
+  if ( definition )
+  {
+    const std::string definitionTemplate =
+      R"(
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<${vectorElementType}> ${className}::${commandName}( ${argumentList} ) const
   {${functionPointerCheck}
     std::vector<${vectorElementType}> ${vectorName};
     ${counterType} ${counterName};
@@ -7751,75 +7864,74 @@ ${enter}  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<${vectorElementType
     }
     return ${vectorName};
   }
-${leave})";
+)";
 
-  std::string definition = replaceWithMap(
-    definitionTemplate,
-    { { "argumentList", argumentListDefinition },
-      { "className",
-        initialSkipCount ? stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) : "Context" },
-      { "commandName", commandName },
-      { "counterName", counterName },
-      { "counterType", commandIt->second.params[vectorParamIndices.begin()->second].type.type },
-      { "enter", enter },
-      { "firstCallArguments", firstCallArguments },
-      { "functionPointerCheck", constructFunctionPointerCheck( commandIt->first, commandIt->second.referencedIn ) },
-      { "leave", leave },
-      { "secondCallArguments", secondCallArguments },
-      { "vectorElementType", vectorElementType },
-      { "vectorName", vectorName },
-      { "vkCommand", commandIt->first } } );
+    std::string counterName =
+      startLowerCase( stripPrefix( commandIt->second.params[vectorParamIndices.begin()->second].name, "p" ) );
+    std::string firstCallArguments = constructCallArgumentsEnhanced(
+      commandIt->second.params, initialSkipCount, true, {}, nonConstPointerParamIndices, true );
+    std::string secondCallArguments = constructCallArgumentsEnhanced(
+      commandIt->second.params, initialSkipCount, false, {}, nonConstPointerParamIndices, true );
+    std::string vectorName =
+      startLowerCase( stripPrefix( commandIt->second.params[vectorParamIndices.begin()->first].name, "p" ) );
 
-  return std::make_pair( declaration, definition );
+    return replaceWithMap(
+      definitionTemplate,
+      { { "argumentList", argumentList },
+        { "className",
+          initialSkipCount ? stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" )
+                           : "Context" },
+        { "commandName", commandName },
+        { "counterName", counterName },
+        { "counterType", commandIt->second.params[vectorParamIndices.begin()->second].type.type },
+        { "firstCallArguments", firstCallArguments },
+        { "functionPointerCheck", constructFunctionPointerCheck( commandIt->first, commandIt->second.referencedIn ) },
+        { "secondCallArguments", secondCallArguments },
+        { "vectorElementType", vectorElementType },
+        { "vectorName", vectorName },
+        { "vkCommand", commandIt->first } } );
+  }
+  else
+  {
+    std::string const declarationTemplate =
+      R"(
+    VULKAN_HPP_NODISCARD std::vector<${vectorElementType}> ${commandName}( ${argumentList} ) const;
+)";
+
+    return replaceWithMap( declarationTemplate,
+                           {
+                             { "argumentList", argumentList },
+                             { "commandName", commandName },
+                             { "vectorElementType", vectorElementType },
+                           } );
+  }
 }
 
-std::pair<std::string, std::string> VulkanHppGenerator::constructRAIIHandleMemberFunctionResultEnumerateTwoVectors(
+std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionResultEnumerateTwoVectors(
   std::map<std::string, CommandData>::const_iterator commandIt,
   size_t                                             initialSkipCount,
   std::map<size_t, size_t> const &                   vectorParamIndices,
-  std::vector<size_t> const &                        nonConstPointerParamIndices ) const
+  std::vector<size_t> const &                        nonConstPointerParamIndices,
+  bool                                               definition ) const
 {
   std::set<size_t> skippedParameters = determineSkippedParams(
     commandIt->second.params, initialSkipCount, vectorParamIndices, nonConstPointerParamIndices, false );
-  std::string argumentListDeclaration =
-    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, false, false, false, false );
-  std::string argumentListDefinition =
-    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, true, false, false, false );
+  std::string argumentList =
+    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, definition, false, false, false );
   auto        firstVectorParamIt  = vectorParamIndices.begin();
   auto        secondVectorParamIt = std::next( firstVectorParamIt );
   std::string commandName =
     determineCommandName( commandIt->first, commandIt->second.params[initialSkipCount - 1].type.type, m_tags );
   std::string counterName =
     startLowerCase( stripPrefix( stripPluralS( commandIt->second.params[firstVectorParamIt->second].name ), "p" ) );
-  std::string enter, leave;
-  std::tie( enter, leave )       = generateProtection( commandIt->second.referencedIn );
-  std::string firstCallArguments = constructCallArgumentsEnhanced(
-    commandIt->second.params, initialSkipCount, true, {}, nonConstPointerParamIndices, true );
-  std::string firstType = stripPrefix( commandIt->second.params[firstVectorParamIt->first].type.type, "Vk" );
-  std::string firstVectorName =
-    startLowerCase( stripPrefix( commandIt->second.params[firstVectorParamIt->first].name, "p" ) );
-  std::string secondCallArguments = constructCallArgumentsEnhanced(
-    commandIt->second.params, initialSkipCount, false, {}, nonConstPointerParamIndices, true );
+  std::string firstType  = stripPrefix( commandIt->second.params[firstVectorParamIt->first].type.type, "Vk" );
   std::string secondType = stripPrefix( commandIt->second.params[secondVectorParamIt->first].type.type, "Vk" );
-  std::string secondVectorName =
-    startLowerCase( stripPrefix( commandIt->second.params[secondVectorParamIt->first].name, "p" ) );
 
-  std::string const declarationTemplate =
-    R"(
-${enter}    VULKAN_HPP_NODISCARD std::pair<std::vector<${firstType}>, std::vector<${secondType}>> ${commandName}( ${argumentList} ) const;
-${leave})";
-
-  std::string declaration = replaceWithMap( declarationTemplate,
-                                            { { "argumentList", argumentListDeclaration },
-                                              { "commandName", commandName },
-                                              { "enter", enter },
-                                              { "firstType", firstType },
-                                              { "leave", leave },
-                                              { "secondType", secondType } } );
-
-  const std::string definitionTemplate =
-    R"(
-${enter}  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<std::vector<${firstType}>, std::vector<${secondType}>> ${className}::${commandName}( ${argumentList} ) const
+  if ( definition )
+  {
+    const std::string definitionTemplate =
+      R"(
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<std::vector<${firstType}>, std::vector<${secondType}>> ${className}::${commandName}( ${argumentList} ) const
   {${functionPointerCheck}
     std::pair<std::vector<${firstType}>, std::vector<${secondType}>> data;
     std::vector<${firstType}> & ${firstVectorName} = data.first;
@@ -7848,27 +7960,46 @@ ${enter}  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<std::vector<${firstTy
     }
     return data;
   }
-${leave})";
+)";
 
-  std::string definition = replaceWithMap(
-    definitionTemplate,
-    { { "argumentList", argumentListDefinition },
-      { "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) },
-      { "commandName", commandName },
-      { "counterName", counterName },
-      { "counterType", commandIt->second.params[firstVectorParamIt->second].type.type },
-      { "enter", enter },
-      { "firstCallArguments", firstCallArguments },
-      { "firstType", firstType },
-      { "firstVectorName", firstVectorName },
-      { "functionPointerCheck", constructFunctionPointerCheck( commandIt->first, commandIt->second.referencedIn ) },
-      { "leave", leave },
-      { "secondCallArguments", secondCallArguments },
-      { "secondType", secondType },
-      { "secondVectorName", secondVectorName },
-      { "vkCommand", commandIt->first } } );
+    std::string firstCallArguments = constructCallArgumentsEnhanced(
+      commandIt->second.params, initialSkipCount, true, {}, nonConstPointerParamIndices, true );
+    std::string firstVectorName =
+      startLowerCase( stripPrefix( commandIt->second.params[firstVectorParamIt->first].name, "p" ) );
+    std::string secondCallArguments = constructCallArgumentsEnhanced(
+      commandIt->second.params, initialSkipCount, false, {}, nonConstPointerParamIndices, true );
+    std::string secondVectorName =
+      startLowerCase( stripPrefix( commandIt->second.params[secondVectorParamIt->first].name, "p" ) );
 
-  return std::make_pair( declaration, definition );
+    return replaceWithMap(
+      definitionTemplate,
+      { { "argumentList", argumentList },
+        { "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) },
+        { "commandName", commandName },
+        { "counterName", counterName },
+        { "counterType", commandIt->second.params[firstVectorParamIt->second].type.type },
+        { "firstCallArguments", firstCallArguments },
+        { "firstType", firstType },
+        { "firstVectorName", firstVectorName },
+        { "functionPointerCheck", constructFunctionPointerCheck( commandIt->first, commandIt->second.referencedIn ) },
+        { "secondCallArguments", secondCallArguments },
+        { "secondType", secondType },
+        { "secondVectorName", secondVectorName },
+        { "vkCommand", commandIt->first } } );
+  }
+  else
+  {
+    std::string const declarationTemplate =
+      R"(
+    VULKAN_HPP_NODISCARD std::pair<std::vector<${firstType}>, std::vector<${secondType}>> ${commandName}( ${argumentList} ) const;
+)";
+
+    return replaceWithMap( declarationTemplate,
+                           { { "argumentList", argumentList },
+                             { "commandName", commandName },
+                             { "firstType", firstType },
+                             { "secondType", secondType } } );
+  }
 }
 
 std::pair<std::string, std::string> VulkanHppGenerator::constructRAIIHandleMemberFunctionResultGetTwoValues(
@@ -7949,45 +8080,24 @@ ${leave})";
   return std::make_pair( declaration, definition );
 }
 
-std::pair<std::string, std::string> VulkanHppGenerator::constructRAIIHandleMemberFunctionResultMulti(
+std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionResultMulti(
   std::map<std::string, CommandData>::const_iterator commandIt,
   size_t                                             initialSkipCount,
-  std::map<size_t, size_t> const &                   vectorParamIndices ) const
+  std::map<size_t, size_t> const &                   vectorParamIndices,
+  bool                                               definition ) const
 {
   std::set<size_t> skippedParameters =
     determineSkippedParams( commandIt->second.params, initialSkipCount, vectorParamIndices, {}, false );
-  std::string argumentListDeclaration =
-    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, false, false, false, false );
-  std::string argumentListDefinition =
-    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, true, false, false, false );
-  std::string callArguments =
-    constructCallArgumentsEnhanced( commandIt->second.params, initialSkipCount, false, {}, {}, true );
+  std::string argumentList =
+    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, definition, false, false, false );
   std::string commandName =
     determineCommandName( commandIt->first, commandIt->second.params[initialSkipCount - 1].type.type, m_tags );
-  std::string enter, leave;
-  std::tie( enter, leave ) = generateProtection( commandIt->second.referencedIn );
 
-  std::pair<bool, std::map<size_t, std::vector<size_t>>> vectorSizeCheck = needsVectorSizeCheck( vectorParamIndices );
-  std::string                                            vectorSizeCheckString =
-    vectorSizeCheck.first
-                                                 ? constructRAIIHandleVectorSizeCheck(
-          commandIt->first, commandIt->second, initialSkipCount, vectorSizeCheck.second, skippedParameters )
-                                                 : "";
-
-  std::string const declarationTemplate =
-    R"(
-${enter}    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result ${commandName}( ${argumentList} ) const;
-${leave})";
-
-  std::string declaration = replaceWithMap( declarationTemplate,
-                                            { { "argumentList", argumentListDeclaration },
-                                              { "commandName", commandName },
-                                              { "enter", enter },
-                                              { "leave", leave } } );
-
-  std::string const definitionTemplate =
-    R"(
-${enter}  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result ${className}::${commandName}( ${argumentList} ) const
+  if ( definition )
+  {
+    std::string const definitionTemplate =
+      R"(
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result ${className}::${commandName}( ${argumentList} ) const
   {${functionPointerCheck}${vectorSizeCheck}
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->${vkCommand}( ${callArguments} ) );
     if ( ${failureCheck} )
@@ -7996,63 +8106,63 @@ ${enter}  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result ${
     }
     return result;
   }
-${leave})";
+)";
 
-  std::string definition = replaceWithMap(
-    definitionTemplate,
-    { { "argumentList", argumentListDefinition },
-      { "callArguments", callArguments },
-      { "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) },
-      { "commandName", commandName },
-      { "enter", enter },
-      { "failureCheck", constructFailureCheck( commandIt->second.successCodes ) },
-      { "functionPointerCheck", constructFunctionPointerCheck( commandIt->first, commandIt->second.referencedIn ) },
-      { "leave", leave },
-      { "vectorSizeCheck", vectorSizeCheckString },
-      { "vkCommand", commandIt->first } } );
+    std::string callArguments =
+      constructCallArgumentsEnhanced( commandIt->second.params, initialSkipCount, false, {}, {}, true );
+    std::pair<bool, std::map<size_t, std::vector<size_t>>> vectorSizeCheck = needsVectorSizeCheck( vectorParamIndices );
+    std::string                                            vectorSizeCheckString =
+      vectorSizeCheck.first
+                                                   ? constructRAIIHandleVectorSizeCheck(
+            commandIt->first, commandIt->second, initialSkipCount, vectorSizeCheck.second, skippedParameters )
+                                                   : "";
 
-  return std::make_pair( declaration, definition );
+    return replaceWithMap(
+      definitionTemplate,
+      { { "argumentList", argumentList },
+        { "callArguments", callArguments },
+        { "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) },
+        { "commandName", commandName },
+        { "failureCheck", constructFailureCheck( commandIt->second.successCodes ) },
+        { "functionPointerCheck", constructFunctionPointerCheck( commandIt->first, commandIt->second.referencedIn ) },
+        { "vectorSizeCheck", vectorSizeCheckString },
+        { "vkCommand", commandIt->first } } );
+  }
+  else
+  {
+    std::string const declarationTemplate =
+      R"(
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result ${commandName}( ${argumentList} ) const;
+)";
+
+    return replaceWithMap( declarationTemplate,
+                           {
+                             { "argumentList", argumentList },
+                             { "commandName", commandName },
+                           } );
+  }
 }
 
-std::pair<std::string, std::string> VulkanHppGenerator::constructRAIIHandleMemberFunctionResultMultiGetValue(
+std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionResultMultiGetValue(
   std::map<std::string, CommandData>::const_iterator commandIt,
   size_t                                             initialSkipCount,
   std::map<size_t, size_t> const &                   vectorParamIndices,
-  std::vector<size_t> const &                        nonConstPointerParamIndices ) const
+  std::vector<size_t> const &                        nonConstPointerParamIndices,
+  bool                                               definition ) const
 {
   std::set<size_t> skippedParameters = determineSkippedParams(
     commandIt->second.params, initialSkipCount, vectorParamIndices, nonConstPointerParamIndices, false );
-  std::string argumentListDeclaration =
-    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, false, false, false, false );
-  std::string argumentListDefinition =
-    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, true, false, false, false );
-  std::string callArguments = constructCallArgumentsEnhanced(
-    commandIt->second.params, initialSkipCount, false, {}, nonConstPointerParamIndices, true );
+  std::string argumentList =
+    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, definition, false, false, false );
   std::string commandName =
     determineCommandName( commandIt->first, commandIt->second.params[initialSkipCount - 1].type.type, m_tags );
-  std::string enter, leave;
-  std::tie( enter, leave ) = generateProtection( commandIt->second.referencedIn );
   std::string returnType = stripPostfix( commandIt->second.params[nonConstPointerParamIndices[0]].type.compose(), "*" );
-  std::string valueName =
-    startLowerCase( stripPrefix( commandIt->second.params[nonConstPointerParamIndices[0]].name, "p" ) );
 
-  std::string const declarationTemplate =
-    R"(
-${enter}  VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::Result, ${returnType}> ${commandName}( ${argumentList} ) const;
-${leave})";
-
-  std::string declaration = replaceWithMap( declarationTemplate,
-                                            {
-                                              { "argumentList", argumentListDeclaration },
-                                              { "commandName", commandName },
-                                              { "enter", enter },
-                                              { "leave", leave },
-                                              { "returnType", returnType },
-                                            } );
-
-  std::string const definitionTemplate =
-    R"(
-${enter}  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<VULKAN_HPP_NAMESPACE::Result, ${returnType}> ${className}::${commandName}( ${argumentList} ) const
+  if ( definition )
+  {
+    std::string const definitionTemplate =
+      R"(
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<VULKAN_HPP_NAMESPACE::Result, ${returnType}> ${className}::${commandName}( ${argumentList} ) const
   {${functionPointerCheck}
     ${returnType} ${valueName};
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->${vkCommand}( ${callArguments} ) );
@@ -8062,61 +8172,60 @@ ${enter}  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<VULKAN_HPP_NAMESPACE:
     }
     return std::make_pair( result, ${valueName} );
   }
-${leave})";
+)";
 
-  std::string definition = replaceWithMap(
-    definitionTemplate,
-    { { "argumentList", argumentListDefinition },
-      { "callArguments", callArguments },
-      { "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) },
-      { "commandName", commandName },
-      { "enter", enter },
-      { "failureCheck", constructFailureCheck( commandIt->second.successCodes ) },
-      { "functionPointerCheck", constructFunctionPointerCheck( commandIt->first, commandIt->second.referencedIn ) },
-      { "leave", leave },
-      { "valueName", valueName },
-      { "returnType", returnType },
-      { "vkCommand", commandIt->first } } );
+    std::string callArguments = constructCallArgumentsEnhanced(
+      commandIt->second.params, initialSkipCount, false, {}, nonConstPointerParamIndices, true );
+    std::string valueName =
+      startLowerCase( stripPrefix( commandIt->second.params[nonConstPointerParamIndices[0]].name, "p" ) );
 
-  return std::make_pair( declaration, definition );
+    return replaceWithMap(
+      definitionTemplate,
+      { { "argumentList", argumentList },
+        { "callArguments", callArguments },
+        { "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) },
+        { "commandName", commandName },
+        { "failureCheck", constructFailureCheck( commandIt->second.successCodes ) },
+        { "functionPointerCheck", constructFunctionPointerCheck( commandIt->first, commandIt->second.referencedIn ) },
+        { "valueName", valueName },
+        { "returnType", returnType },
+        { "vkCommand", commandIt->first } } );
+  }
+  else
+  {
+    std::string const declarationTemplate =
+      R"(
+  VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::Result, ${returnType}> ${commandName}( ${argumentList} ) const;
+)";
+
+    return replaceWithMap( declarationTemplate,
+                           {
+                             { "argumentList", argumentList },
+                             { "commandName", commandName },
+                             { "returnType", returnType },
+                           } );
+  }
 }
 
-std::pair<std::string, std::string> VulkanHppGenerator::constructRAIIHandleMemberFunctionResultMultiGetVectorOfVoid(
+std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionResultMultiGetVectorOfVoid(
   std::map<std::string, CommandData>::const_iterator commandIt,
   size_t                                             initialSkipCount,
   std::map<size_t, size_t> const &                   vectorParamIndices,
-  std::vector<size_t> const &                        nonConstPointerParamIndices ) const
+  std::vector<size_t> const &                        nonConstPointerParamIndices,
+  bool                                               definition ) const
 {
   std::set<size_t> skippedParameters = determineSkippedParams(
     commandIt->second.params, initialSkipCount, vectorParamIndices, nonConstPointerParamIndices, false );
-  std::string argumentListDeclaration =
-    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, false, false, false, false );
-  std::string argumentListDefinition =
-    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, true, false, false, false );
-  std::string callArguments = constructCallArgumentsEnhanced(
-    commandIt->second.params, initialSkipCount, false, {}, nonConstPointerParamIndices, true );
+  std::string argumentList =
+    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, definition, false, false, false );
   std::string commandName =
     determineCommandName( commandIt->first, commandIt->second.params[initialSkipCount - 1].type.type, m_tags );
-  std::string dataName =
-    startLowerCase( stripPrefix( commandIt->second.params[nonConstPointerParamIndices[0]].name, "p" ) );
-  std::string enter, leave;
-  std::tie( enter, leave ) = generateProtection( commandIt->second.referencedIn );
 
-  std::string const declarationTemplate =
-    R"(
-${enter}    template <typename T>
-    VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::Result, std::vector<T>> ${commandName}( ${argumentList} ) const;
-${leave})";
-
-  std::string declaration = replaceWithMap( declarationTemplate,
-                                            { { "argumentList", argumentListDeclaration },
-                                              { "commandName", commandName },
-                                              { "enter", enter },
-                                              { "leave", leave } } );
-
-  std::string const definitionTemplate =
-    R"(
-${enter}  template <typename T>
+  if ( definition )
+  {
+    std::string const definitionTemplate =
+      R"(
+  template <typename T>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<VULKAN_HPP_NAMESPACE::Result, std::vector<T>> ${className}::${commandName}( ${argumentList} ) const
   {${functionPointerCheck}
     VULKAN_HPP_ASSERT( ${dataSize} % sizeof( T ) == 0 );
@@ -8128,64 +8237,62 @@ ${enter}  template <typename T>
     }
     return std::make_pair( result, ${dataName} );
   }
-${leave})";
+)";
 
-  std::string definition = replaceWithMap(
-    definitionTemplate,
-    { { "argumentList", argumentListDefinition },
-      { "callArguments", callArguments },
-      { "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) },
-      { "commandName", commandName },
-      { "dataName", dataName },
-      { "dataSize", commandIt->second.params[nonConstPointerParamIndices[0]].len },
-      { "enter", enter },
-      { "failureCheck", constructFailureCheck( commandIt->second.successCodes ) },
-      { "functionPointerCheck", constructFunctionPointerCheck( commandIt->first, commandIt->second.referencedIn ) },
-      { "leave", leave },
-      { "vkCommand", commandIt->first } } );
+    std::string callArguments = constructCallArgumentsEnhanced(
+      commandIt->second.params, initialSkipCount, false, {}, nonConstPointerParamIndices, true );
+    std::string dataName =
+      startLowerCase( stripPrefix( commandIt->second.params[nonConstPointerParamIndices[0]].name, "p" ) );
 
-  return std::make_pair( declaration, definition );
+    return replaceWithMap(
+      definitionTemplate,
+      { { "argumentList", argumentList },
+        { "callArguments", callArguments },
+        { "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) },
+        { "commandName", commandName },
+        { "dataName", dataName },
+        { "dataSize", commandIt->second.params[nonConstPointerParamIndices[0]].len },
+        { "failureCheck", constructFailureCheck( commandIt->second.successCodes ) },
+        { "functionPointerCheck", constructFunctionPointerCheck( commandIt->first, commandIt->second.referencedIn ) },
+        { "vkCommand", commandIt->first } } );
+  }
+  else
+  {
+    std::string const declarationTemplate =
+      R"(
+    template <typename T>
+    VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::Result, std::vector<T>> ${commandName}( ${argumentList} ) const;
+)";
+
+    return replaceWithMap( declarationTemplate,
+                           {
+                             { "argumentList", argumentList },
+                             { "commandName", commandName },
+                           } );
+  }
 }
 
-std::pair<std::string, std::string>
-  VulkanHppGenerator::constructRAIIHandleMemberFunctionResultMultiGetVectorOfVoidSingular(
-    std::map<std::string, CommandData>::const_iterator commandIt,
-    size_t                                             initialSkipCount,
-    std::map<size_t, size_t> const &                   vectorParamIndices,
-    std::vector<size_t> const &                        nonConstPointerParamIndices ) const
+std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionResultMultiGetVectorOfVoidSingular(
+  std::map<std::string, CommandData>::const_iterator commandIt,
+  size_t                                             initialSkipCount,
+  std::map<size_t, size_t> const &                   vectorParamIndices,
+  std::vector<size_t> const &                        nonConstPointerParamIndices,
+  bool                                               definition ) const
 {
   assert( nonConstPointerParamIndices.size() == 1 );
   std::set<size_t> skippedParameters = determineSkippedParams(
     commandIt->second.params, initialSkipCount, vectorParamIndices, nonConstPointerParamIndices, true );
   std::set<size_t> singularParams = determineSingularParams( nonConstPointerParamIndices[0], vectorParamIndices );
-  std::string      argumentListDeclaration = constructArgumentListEnhanced(
-    commandIt->second.params, skippedParameters, singularParams, false, false, false, false );
-  std::string argumentListDefinition = constructArgumentListEnhanced(
-    commandIt->second.params, skippedParameters, singularParams, true, false, false, false );
-  std::string callArguments = constructCallArgumentsEnhanced(
-    commandIt->second.params, initialSkipCount, false, singularParams, nonConstPointerParamIndices, true );
+  std::string      argumentList   = constructArgumentListEnhanced(
+    commandIt->second.params, skippedParameters, singularParams, definition, false, false, false );
   std::string commandName = stripPluralS(
     determineCommandName( commandIt->first, commandIt->second.params[initialSkipCount - 1].type.type, m_tags ) );
-  std::string dataName =
-    startLowerCase( stripPrefix( commandIt->second.params[nonConstPointerParamIndices[0]].name, "p" ) );
-  std::string enter, leave;
-  std::tie( enter, leave ) = generateProtection( commandIt->second.referencedIn );
 
-  std::string const singularDeclarationTemplate =
-    R"(
-${enter}    template <typename T>
-    VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::Result, T> ${commandName}( ${argumentList} ) const;
-${leave})";
-
-  std::string declaration = replaceWithMap( singularDeclarationTemplate,
-                                            { { "argumentList", argumentListDeclaration },
-                                              { "commandName", commandName },
-                                              { "enter", enter },
-                                              { "leave", leave } } );
-
-  std::string const singularDefinitionTemplate =
-    R"(
-${enter}  template <typename T>
+  if ( definition )
+  {
+    std::string const singularDefinitionTemplate =
+      R"(
+  template <typename T>
   VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::Result, T> ${className}::${commandName}( ${argumentList} ) const
   {
     T ${dataName};
@@ -8196,121 +8303,114 @@ ${enter}  template <typename T>
     }
     return std::make_pair( result, ${dataName} );
   }
-${leave})";
+)";
 
-  std::string definition =
-    replaceWithMap( singularDefinitionTemplate,
-                    { { "argumentList", argumentListDefinition },
-                      { "callArguments", callArguments },
-                      { "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) },
-                      { "commandName", commandName },
-                      { "dataName", dataName },
-                      { "enter", enter },
-                      { "failureCheck", constructFailureCheck( commandIt->second.successCodes ) },
-                      { "leave", leave },
-                      { "vkCommand", commandIt->first } } );
+    std::string callArguments = constructCallArgumentsEnhanced(
+      commandIt->second.params, initialSkipCount, false, singularParams, nonConstPointerParamIndices, true );
+    std::string dataName =
+      startLowerCase( stripPrefix( commandIt->second.params[nonConstPointerParamIndices[0]].name, "p" ) );
 
-  return std::make_pair( declaration, definition );
+    return replaceWithMap(
+      singularDefinitionTemplate,
+      { { "argumentList", argumentList },
+        { "callArguments", callArguments },
+        { "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) },
+        { "commandName", commandName },
+        { "dataName", dataName },
+        { "failureCheck", constructFailureCheck( commandIt->second.successCodes ) },
+        { "vkCommand", commandIt->first } } );
+  }
+  else
+  {
+    std::string const singularDeclarationTemplate =
+      R"(
+    template <typename T>
+    VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::Result, T> ${commandName}( ${argumentList} ) const;
+)";
+
+    return replaceWithMap( singularDeclarationTemplate,
+                           {
+                             { "argumentList", argumentList },
+                             { "commandName", commandName },
+                           } );
+  }
 }
 
-std::pair<std::string, std::string> VulkanHppGenerator::constructRAIIHandleMemberFunctionResultMultiNoErrors(
+std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionResultMultiNoErrors(
   std::map<std::string, CommandData>::const_iterator commandIt,
   size_t                                             initialSkipCount,
-  std::map<size_t, size_t> const &                   vectorParamIndices ) const
+  std::map<size_t, size_t> const &                   vectorParamIndices,
+  bool                                               definition ) const
 {
   std::set<size_t> skippedParameters =
     determineSkippedParams( commandIt->second.params, initialSkipCount, vectorParamIndices, {}, false );
-  std::string argumentListDeclaration =
-    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, false, false, false, false );
-  std::string argumentListDefinition =
-    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, true, false, false, false );
-  std::string callArguments =
-    constructCallArgumentsEnhanced( commandIt->second.params, initialSkipCount, false, {}, {}, true );
+  std::string argumentList =
+    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, definition, false, false, false );
   std::string commandName =
     determineCommandName( commandIt->first, commandIt->second.params[initialSkipCount - 1].type.type, m_tags );
-  std::string enter, leave;
-  std::tie( enter, leave ) = generateProtection( commandIt->second.referencedIn );
 
-  std::pair<bool, std::map<size_t, std::vector<size_t>>> vectorSizeCheck = needsVectorSizeCheck( vectorParamIndices );
-  std::string                                            vectorSizeCheckString =
-    vectorSizeCheck.first
-                                                 ? constructRAIIHandleVectorSizeCheck(
-          commandIt->first, commandIt->second, initialSkipCount, vectorSizeCheck.second, skippedParameters )
-                                                 : "";
-
-  std::string const declarationTemplate =
-    R"(
-${enter}    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result ${commandName}( ${argumentList} ) const VULKAN_HPP_NOEXCEPT;
-${leave})";
-
-  std::string declaration = replaceWithMap( declarationTemplate,
-                                            { { "argumentList", argumentListDeclaration },
-                                              { "commandName", commandName },
-                                              { "enter", enter },
-                                              { "leave", leave } } );
-
-  std::string const definitionTemplate =
-    R"(
-${enter}  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result ${className}::${commandName}( ${argumentList} ) const VULKAN_HPP_NOEXCEPT
+  if ( definition )
+  {
+    std::string const definitionTemplate =
+      R"(
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result ${className}::${commandName}( ${argumentList} ) const VULKAN_HPP_NOEXCEPT
   {${functionPointerCheck}${vectorSizeCheck}
     return static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->${vkCommand}( ${callArguments} ) );
   }
-${leave})";
+)";
 
-  std::string definition = replaceWithMap(
-    definitionTemplate,
-    { { "argumentList", argumentListDefinition },
-      { "callArguments", callArguments },
-      { "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) },
-      { "commandName", commandName },
-      { "enter", enter },
-      { "functionPointerCheck", constructFunctionPointerCheck( commandIt->first, commandIt->second.referencedIn ) },
-      { "leave", leave },
-      { "vectorSizeCheck", vectorSizeCheckString },
-      { "vkCommand", commandIt->first } } );
+    std::string callArguments =
+      constructCallArgumentsEnhanced( commandIt->second.params, initialSkipCount, false, {}, {}, true );
+    std::pair<bool, std::map<size_t, std::vector<size_t>>> vectorSizeCheck = needsVectorSizeCheck( vectorParamIndices );
+    std::string                                            vectorSizeCheckString =
+      vectorSizeCheck.first
+                                                   ? constructRAIIHandleVectorSizeCheck(
+            commandIt->first, commandIt->second, initialSkipCount, vectorSizeCheck.second, skippedParameters )
+                                                   : "";
 
-  return std::make_pair( declaration, definition );
+    return replaceWithMap(
+      definitionTemplate,
+      { { "argumentList", argumentList },
+        { "callArguments", callArguments },
+        { "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) },
+        { "commandName", commandName },
+        { "functionPointerCheck", constructFunctionPointerCheck( commandIt->first, commandIt->second.referencedIn ) },
+        { "vectorSizeCheck", vectorSizeCheckString },
+        { "vkCommand", commandIt->first } } );
+  }
+  else
+  {
+    std::string const declarationTemplate =
+      R"(
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result ${commandName}( ${argumentList} ) const VULKAN_HPP_NOEXCEPT;
+)";
+
+    return replaceWithMap( declarationTemplate,
+                           {
+                             { "argumentList", argumentList },
+                             { "commandName", commandName },
+                           } );
+  }
 }
 
-std::pair<std::string, std::string> VulkanHppGenerator::constructRAIIHandleMemberFunctionResultSingle(
+std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionResultSingle(
   std::map<std::string, CommandData>::const_iterator commandIt,
   size_t                                             initialSkipCount,
-  std::map<size_t, size_t> const &                   vectorParamIndices ) const
+  std::map<size_t, size_t> const &                   vectorParamIndices,
+  bool                                               definition ) const
 {
   std::set<size_t> skippedParameters =
     determineSkippedParams( commandIt->second.params, initialSkipCount, vectorParamIndices, {}, false );
-  std::string argumentListDeclaration =
-    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, false, false, false, false );
-  std::string argumentListDefinition =
-    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, true, false, false, false );
-  std::string callArguments =
-    constructCallArgumentsEnhanced( commandIt->second.params, initialSkipCount, false, {}, {}, true );
+  std::string argumentList =
+    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, definition, false, false, false );
   std::string commandName =
     determineCommandName( commandIt->first, commandIt->second.params[initialSkipCount - 1].type.type, m_tags );
-  std::string enter, leave;
-  std::tie( enter, leave ) = generateProtection( commandIt->second.referencedIn );
 
-  std::pair<bool, std::map<size_t, std::vector<size_t>>> vectorSizeCheck = needsVectorSizeCheck( vectorParamIndices );
-  std::string                                            vectorSizeCheckString =
-    vectorSizeCheck.first
-                                                 ? constructRAIIHandleVectorSizeCheck(
-          commandIt->first, commandIt->second, initialSkipCount, vectorSizeCheck.second, skippedParameters )
-                                                 : "";
-
-  std::string const declarationTemplate =
-    R"(
-${enter}    void ${commandName}( ${argumentList} ) const;
-${leave})";
-
-  std::string declaration = replaceWithMap( declarationTemplate,
-                                            { { "argumentList", argumentListDeclaration },
-                                              { "commandName", commandName },
-                                              { "enter", enter },
-                                              { "leave", leave } } );
-
-  std::string const definitionTemplate =
-    R"(
-${enter}  VULKAN_HPP_INLINE void ${className}::${commandName}( ${argumentList} ) const
+  if ( definition )
+  {
+    std::string const definitionTemplate =
+      R"(
+  VULKAN_HPP_INLINE void ${className}::${commandName}( ${argumentList} ) const
   {${functionPointerCheck}${vectorSizeCheck}
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->${vkCommand}( ${callArguments} ) );
     if ( ${failureCheck} )
@@ -8318,61 +8418,62 @@ ${enter}  VULKAN_HPP_INLINE void ${className}::${commandName}( ${argumentList} )
       throwResultException( result, VULKAN_HPP_NAMESPACE_STRING"::${className}::${commandName}" );
     }
   }
-${leave})";
+)";
 
-  std::string definition = replaceWithMap(
-    definitionTemplate,
-    { { "argumentList", argumentListDefinition },
-      { "callArguments", callArguments },
-      { "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) },
-      { "commandName", commandName },
-      { "enter", enter },
-      { "failureCheck", constructFailureCheck( commandIt->second.successCodes ) },
-      { "functionPointerCheck", constructFunctionPointerCheck( commandIt->first, commandIt->second.referencedIn ) },
-      { "leave", leave },
-      { "vectorSizeCheck", vectorSizeCheckString },
-      { "vkCommand", commandIt->first } } );
+    std::string callArguments =
+      constructCallArgumentsEnhanced( commandIt->second.params, initialSkipCount, false, {}, {}, true );
+    std::pair<bool, std::map<size_t, std::vector<size_t>>> vectorSizeCheck = needsVectorSizeCheck( vectorParamIndices );
+    std::string                                            vectorSizeCheckString =
+      vectorSizeCheck.first
+                                                   ? constructRAIIHandleVectorSizeCheck(
+            commandIt->first, commandIt->second, initialSkipCount, vectorSizeCheck.second, skippedParameters )
+                                                   : "";
 
-  return std::make_pair( declaration, definition );
+    return replaceWithMap(
+      definitionTemplate,
+      { { "argumentList", argumentList },
+        { "callArguments", callArguments },
+        { "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) },
+        { "commandName", commandName },
+        { "failureCheck", constructFailureCheck( commandIt->second.successCodes ) },
+        { "functionPointerCheck", constructFunctionPointerCheck( commandIt->first, commandIt->second.referencedIn ) },
+        { "vectorSizeCheck", vectorSizeCheckString },
+        { "vkCommand", commandIt->first } } );
+  }
+  else
+  {
+    std::string const declarationTemplate =
+      R"(
+    void ${commandName}( ${argumentList} ) const;
+)";
+
+    return replaceWithMap( declarationTemplate,
+                           {
+                             { "argumentList", argumentList },
+                             { "commandName", commandName },
+                           } );
+  }
 }
 
-std::pair<std::string, std::string> VulkanHppGenerator::constructRAIIHandleMemberFunctionResultSingleGetChain(
+std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionResultSingleGetChain(
   std::map<std::string, CommandData>::const_iterator commandIt,
   size_t                                             initialSkipCount,
   std::map<size_t, size_t> const &                   vectorParamIndices,
-  std::vector<size_t> const &                        nonConstPointerParamIndices ) const
+  std::vector<size_t> const &                        nonConstPointerParamIndices,
+  bool                                               definition ) const
 {
   std::set<size_t> skippedParameters = determineSkippedParams(
     commandIt->second.params, initialSkipCount, vectorParamIndices, nonConstPointerParamIndices, false );
-  std::string argumentListDeclaration =
-    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, false, false, false, false );
-  std::string argumentListDefinition =
-    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, true, false, false, false );
-  std::string callArguments = constructCallArgumentsEnhanced(
-    commandIt->second.params, initialSkipCount, false, {}, nonConstPointerParamIndices, true );
+  std::string argumentList =
+    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, definition, false, false, false );
   std::string commandName =
     determineCommandName( commandIt->first, commandIt->second.params[initialSkipCount - 1].type.type, m_tags );
-  std::string enter, leave;
-  std::tie( enter, leave ) = generateProtection( commandIt->second.referencedIn );
-  std::string returnType = stripPostfix( commandIt->second.params[nonConstPointerParamIndices[0]].type.compose(), "*" );
-  std::string returnVariable =
-    startLowerCase( stripPrefix( commandIt->second.params[nonConstPointerParamIndices[0]].name, "p" ) );
 
-  std::string const declarationTemplate =
-    R"(
-${enter}  template <typename X, typename Y, typename... Z>
-    VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> ${commandName}( ${argumentList} ) const;
-${leave})";
-
-  std::string declaration = replaceWithMap( declarationTemplate,
-                                            { { "argumentList", argumentListDeclaration },
-                                              { "commandName", commandName },
-                                              { "enter", enter },
-                                              { "leave", leave } } );
-
-  std::string const functionTemplate =
-    R"(
-${enter}  template <typename X, typename Y, typename... Z>
+  if ( definition )
+  {
+    std::string const functionTemplate =
+      R"(
+  template <typename X, typename Y, typename... Z>
   VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> ${className}::${commandName}( ${argumentList} ) const
   {
     StructureChain<X, Y, Z...> structureChain;
@@ -8384,64 +8485,62 @@ ${enter}  template <typename X, typename Y, typename... Z>
     }
     return structureChain;
   }
-${leave})";
+)";
 
-  std::string definition =
-    replaceWithMap( functionTemplate,
-                    { { "argumentList", argumentListDefinition },
-                      { "callArguments", callArguments },
-                      { "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) },
-                      { "commandName", commandName },
-                      { "enter", enter },
-                      { "failureCheck", constructFailureCheck( commandIt->second.successCodes ) },
-                      { "leave", leave },
-                      { "returnVariable", returnVariable },
-                      { "returnType", returnType },
-                      { "vkCommand", commandIt->first } } );
+    std::string callArguments = constructCallArgumentsEnhanced(
+      commandIt->second.params, initialSkipCount, false, {}, nonConstPointerParamIndices, true );
+    std::string returnType =
+      stripPostfix( commandIt->second.params[nonConstPointerParamIndices[0]].type.compose(), "*" );
+    std::string returnVariable =
+      startLowerCase( stripPrefix( commandIt->second.params[nonConstPointerParamIndices[0]].name, "p" ) );
 
-  return std::make_pair( declaration, definition );
+    return replaceWithMap(
+      functionTemplate,
+      { { "argumentList", argumentList },
+        { "callArguments", callArguments },
+        { "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) },
+        { "commandName", commandName },
+        { "failureCheck", constructFailureCheck( commandIt->second.successCodes ) },
+        { "returnVariable", returnVariable },
+        { "returnType", returnType },
+        { "vkCommand", commandIt->first } } );
+  }
+  else
+  {
+    std::string const declarationTemplate =
+      R"(
+  template <typename X, typename Y, typename... Z>
+    VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> ${commandName}( ${argumentList} ) const;
+)";
+
+    return replaceWithMap( declarationTemplate,
+                           {
+                             { "argumentList", argumentList },
+                             { "commandName", commandName },
+                           } );
+  }
 }
 
-std::pair<std::string, std::string> VulkanHppGenerator::constructRAIIHandleMemberFunctionResultSingleGetVector(
+std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionResultSingleGetVector(
   std::map<std::string, CommandData>::const_iterator commandIt,
   size_t                                             initialSkipCount,
   std::map<size_t, size_t> const &                   vectorParamIndices,
-  size_t                                             returnParamIndex ) const
+  size_t                                             returnParamIndex,
+  bool                                               definition ) const
 {
   std::set<size_t> skippedParameters = determineSkippedParams(
     commandIt->second.params, initialSkipCount, vectorParamIndices, { returnParamIndex }, false );
-  std::string argumentListDeclaration =
-    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, false, false, false, false );
-  std::string argumentListDefinition =
-    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, true, false, false, false );
-  std::string callArguments =
-    constructCallArgumentsEnhanced( commandIt->second.params, initialSkipCount, false, {}, { returnParamIndex }, true );
+  std::string argumentList =
+    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, definition, false, false, false );
   std::string commandName =
     determineCommandName( commandIt->first, commandIt->second.params[initialSkipCount - 1].type.type, m_tags );
-  std::string enter, leave;
-  std::tie( enter, leave )      = generateProtection( commandIt->second.referencedIn );
   std::string vectorElementType = commandIt->second.params[returnParamIndex].type.type;
-  std::string vectorName        = startLowerCase( stripPrefix( commandIt->second.params[returnParamIndex].name, "p" ) );
-  std::string vectorSize =
-    startLowerCase( stripPrefix( commandIt->second.params[vectorParamIndices.begin()->first].name, "p" ) ) + ".size()";
 
-  std::string const declarationTemplate =
-    R"(
-${enter}    VULKAN_HPP_NODISCARD std::vector<${vectorElementType}> ${commandName}( ${argumentList} ) const;
-${leave})";
-
-  std::string declaration = replaceWithMap( declarationTemplate,
-                                            {
-                                              { "argumentList", argumentListDeclaration },
-                                              { "commandName", commandName },
-                                              { "enter", enter },
-                                              { "leave", leave },
-                                              { "vectorElementType", vectorElementType },
-                                            } );
-
-  std::string const definitionTemplate =
-    R"(
-${enter}  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<${vectorElementType}> ${className}::${commandName}( ${argumentList} ) const
+  if ( definition )
+  {
+    std::string const definitionTemplate =
+      R"(
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<${vectorElementType}> ${className}::${commandName}( ${argumentList} ) const
   {${functionPointerCheck}
     std::vector<${vectorElementType}> ${vectorName}( ${vectorSize} );
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->${vkCommand}( ${callArguments} ) );
@@ -8451,71 +8550,65 @@ ${enter}  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<${vectorElementType
     }
     return ${vectorName};
   }
-${leave})";
+)";
 
-  std::string definition = replaceWithMap(
-    definitionTemplate,
-    { { "argumentList", argumentListDefinition },
-      { "callArguments", callArguments },
-      { "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) },
-      { "commandName", commandName },
-      { "enter", enter },
-      { "failureCheck", constructFailureCheck( commandIt->second.successCodes ) },
-      { "functionPointerCheck", constructFunctionPointerCheck( commandIt->first, commandIt->second.referencedIn ) },
-      { "leave", leave },
-      { "vectorElementType", vectorElementType },
-      { "vectorName", vectorName },
-      { "vectorSize", vectorSize },
-      { "vkCommand", commandIt->first } } );
+    std::string callArguments = constructCallArgumentsEnhanced(
+      commandIt->second.params, initialSkipCount, false, {}, { returnParamIndex }, true );
+    std::string vectorName = startLowerCase( stripPrefix( commandIt->second.params[returnParamIndex].name, "p" ) );
+    std::string vectorSize =
+      startLowerCase( stripPrefix( commandIt->second.params[vectorParamIndices.begin()->first].name, "p" ) ) +
+      ".size()";
 
-  return std::make_pair( declaration, definition );
+    return replaceWithMap(
+      definitionTemplate,
+      { { "argumentList", argumentList },
+        { "callArguments", callArguments },
+        { "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) },
+        { "commandName", commandName },
+        { "failureCheck", constructFailureCheck( commandIt->second.successCodes ) },
+        { "functionPointerCheck", constructFunctionPointerCheck( commandIt->first, commandIt->second.referencedIn ) },
+        { "vectorElementType", vectorElementType },
+        { "vectorName", vectorName },
+        { "vectorSize", vectorSize },
+        { "vkCommand", commandIt->first } } );
+  }
+  else
+  {
+    std::string const declarationTemplate =
+      R"(
+    VULKAN_HPP_NODISCARD std::vector<${vectorElementType}> ${commandName}( ${argumentList} ) const;
+)";
+
+    return replaceWithMap( declarationTemplate,
+                           {
+                             { "argumentList", argumentList },
+                             { "commandName", commandName },
+                             { "vectorElementType", vectorElementType },
+                           } );
+  }
 }
 
-std::pair<std::string, std::string> VulkanHppGenerator::constructRAIIHandleMemberFunctionResultSingleGetVectorAndValue(
+std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionResultSingleGetVectorAndValue(
   std::map<std::string, CommandData>::const_iterator commandIt,
   size_t                                             initialSkipCount,
   std::map<size_t, size_t> const &                   vectorParamIndices,
-  std::vector<size_t> const &                        nonConstPointerParamIndices ) const
+  std::vector<size_t> const &                        nonConstPointerParamIndices,
+  bool                                               definition ) const
 {
   std::set<size_t> skippedParameters = determineSkippedParams(
     commandIt->second.params, initialSkipCount, vectorParamIndices, nonConstPointerParamIndices, false );
-  std::string argumentListDeclaration =
-    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, false, false, false, false );
-  std::string argumentListDefinition =
-    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, true, false, false, false );
-  std::string callArguments = constructCallArgumentsEnhanced(
-    commandIt->second.params, initialSkipCount, false, {}, nonConstPointerParamIndices, true );
+  std::string argumentList =
+    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, definition, false, false, false );
   std::string commandName =
     determineCommandName( commandIt->first, commandIt->second.params[initialSkipCount - 1].type.type, m_tags );
-  std::string enter, leave;
-  std::tie( enter, leave ) = generateProtection( commandIt->second.referencedIn );
-  std::string valueName =
-    startLowerCase( stripPrefix( commandIt->second.params[nonConstPointerParamIndices[1]].name, "p" ) );
   std::string valueType         = commandIt->second.params[nonConstPointerParamIndices[1]].type.type;
   std::string vectorElementType = commandIt->second.params[nonConstPointerParamIndices[0]].type.type;
-  std::string vectorName =
-    startLowerCase( stripPrefix( commandIt->second.params[nonConstPointerParamIndices[0]].name, "p" ) );
-  std::string vectorSize =
-    startLowerCase( stripPrefix( commandIt->second.params[vectorParamIndices.begin()->first].name, "p" ) ) + ".size()";
 
-  std::string const declarationTemplate =
-    R"(
-${enter}    VULKAN_HPP_NODISCARD std::pair<std::vector<${vectorElementType}>, ${valueType}> ${commandName}( ${argumentList} ) const;
-${leave})";
-
-  std::string declaration = replaceWithMap( declarationTemplate,
-                                            {
-                                              { "argumentList", argumentListDeclaration },
-                                              { "commandName", commandName },
-                                              { "enter", enter },
-                                              { "leave", leave },
-                                              { "valueType", valueType },
-                                              { "vectorElementType", vectorElementType },
-                                            } );
-
-  std::string const definitionTemplate =
-    R"(
-${enter}  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<std::vector<${vectorElementType}>, ${valueType}> ${className}::${commandName}( ${argumentList} ) const
+  if ( definition )
+  {
+    std::string const definitionTemplate =
+      R"(
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<std::vector<${vectorElementType}>, ${valueType}> ${className}::${commandName}( ${argumentList} ) const
   {${functionPointerCheck}
     std::pair<std::vector<${vectorElementType}>, ${valueType}> data( std::piecewise_construct, std::forward_as_tuple( ${vectorSize} ), std::forward_as_tuple( 0 ) );
     std::vector<${vectorElementType}> & ${vectorName} = data.first;
@@ -8527,65 +8620,70 @@ ${enter}  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<std::vector<${vectorE
     }
     return data;
   }
-${leave})";
+)";
 
-  std::string definition = replaceWithMap(
-    definitionTemplate,
-    { { "argumentList", argumentListDefinition },
-      { "callArguments", callArguments },
-      { "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) },
-      { "commandName", commandName },
-      { "enter", enter },
-      { "failureCheck", constructFailureCheck( commandIt->second.successCodes ) },
-      { "functionPointerCheck", constructFunctionPointerCheck( commandIt->first, commandIt->second.referencedIn ) },
-      { "leave", leave },
-      { "valueName", valueName },
-      { "valueType", valueType },
-      { "vectorElementType", vectorElementType },
-      { "vectorName", vectorName },
-      { "vectorSize", vectorSize },
-      { "vkCommand", commandIt->first } } );
+    std::string callArguments = constructCallArgumentsEnhanced(
+      commandIt->second.params, initialSkipCount, false, {}, nonConstPointerParamIndices, true );
+    std::string valueName =
+      startLowerCase( stripPrefix( commandIt->second.params[nonConstPointerParamIndices[1]].name, "p" ) );
+    std::string vectorName =
+      startLowerCase( stripPrefix( commandIt->second.params[nonConstPointerParamIndices[0]].name, "p" ) );
+    std::string vectorSize =
+      startLowerCase( stripPrefix( commandIt->second.params[vectorParamIndices.begin()->first].name, "p" ) ) +
+      ".size()";
 
-  return std::make_pair( declaration, definition );
+    return replaceWithMap(
+      definitionTemplate,
+      { { "argumentList", argumentList },
+        { "callArguments", callArguments },
+        { "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) },
+        { "commandName", commandName },
+        { "failureCheck", constructFailureCheck( commandIt->second.successCodes ) },
+        { "functionPointerCheck", constructFunctionPointerCheck( commandIt->first, commandIt->second.referencedIn ) },
+        { "valueName", valueName },
+        { "valueType", valueType },
+        { "vectorElementType", vectorElementType },
+        { "vectorName", vectorName },
+        { "vectorSize", vectorSize },
+        { "vkCommand", commandIt->first } } );
+  }
+  else
+  {
+    std::string const declarationTemplate =
+      R"(
+    VULKAN_HPP_NODISCARD std::pair<std::vector<${vectorElementType}>, ${valueType}> ${commandName}( ${argumentList} ) const;
+)";
+
+    return replaceWithMap( declarationTemplate,
+                           {
+                             { "argumentList", argumentList },
+                             { "commandName", commandName },
+                             { "valueType", valueType },
+                             { "vectorElementType", vectorElementType },
+                           } );
+  }
 }
 
-std::pair<std::string, std::string> VulkanHppGenerator::constructRAIIHandleMemberFunctionResultSingleGetVectorOfVoid(
+std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionResultSingleGetVectorOfVoid(
   std::map<std::string, CommandData>::const_iterator commandIt,
   size_t                                             initialSkipCount,
   std::map<size_t, size_t> const &                   vectorParamIndices,
-  std::vector<size_t> const &                        nonConstPointerParamIndices ) const
+  std::vector<size_t> const &                        nonConstPointerParamIndices,
+  bool                                               definition ) const
 {
   assert( nonConstPointerParamIndices.size() == 1 );
   std::set<size_t> skippedParameters = determineSkippedParams(
     commandIt->second.params, initialSkipCount, vectorParamIndices, nonConstPointerParamIndices, false );
-  std::string argumentListDeclaration =
-    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, false, false, false, false );
-  std::string argumentListDefinition =
-    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, true, false, false, false );
-  std::string callArguments = constructCallArgumentsEnhanced(
-    commandIt->second.params, initialSkipCount, false, {}, nonConstPointerParamIndices, true );
+  std::string argumentList =
+    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, definition, false, false, false );
   std::string commandName =
     determineCommandName( commandIt->first, commandIt->second.params[initialSkipCount - 1].type.type, m_tags );
-  std::string dataName =
-    startLowerCase( stripPrefix( commandIt->second.params[nonConstPointerParamIndices[0]].name, "p" ) );
-  std::string enter, leave;
-  std::tie( enter, leave ) = generateProtection( commandIt->second.referencedIn );
 
-  std::string const declarationTemplate =
-    R"(
-${enter}    template <typename T>
-    VULKAN_HPP_NODISCARD std::vector<T> ${commandName}( ${argumentList} ) const;
-${leave})";
-
-  std::string declaration = replaceWithMap( declarationTemplate,
-                                            { { "argumentList", argumentListDeclaration },
-                                              { "commandName", commandName },
-                                              { "enter", enter },
-                                              { "leave", leave } } );
-
-  std::string const definitionTemplate =
-    R"(
-${enter}  template <typename T>
+  if ( definition )
+  {
+    std::string const definitionTemplate =
+      R"(
+  template <typename T>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<T> ${className}::${commandName}( ${argumentList} ) const
   {${functionPointerCheck}
     VULKAN_HPP_ASSERT( ${dataSize} % sizeof( T ) == 0 );
@@ -8597,65 +8695,63 @@ ${enter}  template <typename T>
     }
     return ${dataName};
   }
-${leave})";
+)";
 
-  std::string definition = replaceWithMap(
-    definitionTemplate,
-    { { "argumentList", argumentListDefinition },
-      { "callArguments", callArguments },
-      { "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) },
-      { "commandName", commandName },
-      { "dataName", dataName },
-      { "dataSize", commandIt->second.params[nonConstPointerParamIndices[0]].len },
-      { "enter", enter },
-      { "failureCheck", constructFailureCheck( commandIt->second.successCodes ) },
-      { "functionPointerCheck", constructFunctionPointerCheck( commandIt->first, commandIt->second.referencedIn ) },
-      { "leave", leave },
-      { "vkCommand", commandIt->first } } );
+    std::string callArguments = constructCallArgumentsEnhanced(
+      commandIt->second.params, initialSkipCount, false, {}, nonConstPointerParamIndices, true );
+    std::string dataName =
+      startLowerCase( stripPrefix( commandIt->second.params[nonConstPointerParamIndices[0]].name, "p" ) );
 
-  return std::make_pair( declaration, definition );
+    return replaceWithMap(
+      definitionTemplate,
+      { { "argumentList", argumentList },
+        { "callArguments", callArguments },
+        { "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) },
+        { "commandName", commandName },
+        { "dataName", dataName },
+        { "dataSize", commandIt->second.params[nonConstPointerParamIndices[0]].len },
+        { "failureCheck", constructFailureCheck( commandIt->second.successCodes ) },
+        { "functionPointerCheck", constructFunctionPointerCheck( commandIt->first, commandIt->second.referencedIn ) },
+        { "vkCommand", commandIt->first } } );
+  }
+  else
+  {
+    std::string const declarationTemplate =
+      R"(
+    template <typename T>
+    VULKAN_HPP_NODISCARD std::vector<T> ${commandName}( ${argumentList} ) const;
+)";
+
+    return replaceWithMap( declarationTemplate,
+                           {
+                             { "argumentList", argumentList },
+                             { "commandName", commandName },
+                           } );
+  }
 }
 
-std::pair<std::string, std::string>
-  VulkanHppGenerator::constructRAIIHandleMemberFunctionResultSingleGetVectorOfVoidSingular(
-    std::map<std::string, CommandData>::const_iterator commandIt,
-    size_t                                             initialSkipCount,
-    std::map<size_t, size_t> const &                   vectorParamIndices,
-    std::vector<size_t> const &                        nonConstPointerParamIndices ) const
+std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionResultSingleGetVectorOfVoidSingular(
+  std::map<std::string, CommandData>::const_iterator commandIt,
+  size_t                                             initialSkipCount,
+  std::map<size_t, size_t> const &                   vectorParamIndices,
+  std::vector<size_t> const &                        nonConstPointerParamIndices,
+  bool                                               definition ) const
 {
   assert( nonConstPointerParamIndices.size() == 1 );
 
   std::set<size_t> skippedParameters = determineSkippedParams(
     commandIt->second.params, initialSkipCount, vectorParamIndices, nonConstPointerParamIndices, true );
   std::set<size_t> singularParams = determineSingularParams( nonConstPointerParamIndices[0], vectorParamIndices );
-  std::string      argumentListDeclaration = constructArgumentListEnhanced(
-    commandIt->second.params, skippedParameters, singularParams, false, false, false, false );
-  std::string argumentListDefinition = constructArgumentListEnhanced(
-    commandIt->second.params, skippedParameters, singularParams, true, false, false, false );
-  std::string callArguments = constructCallArgumentsEnhanced(
-    commandIt->second.params, initialSkipCount, false, singularParams, nonConstPointerParamIndices, true );
+  std::string      argumentList   = constructArgumentListEnhanced(
+    commandIt->second.params, skippedParameters, singularParams, definition, false, false, false );
   std::string commandName = stripPluralS(
     determineCommandName( commandIt->first, commandIt->second.params[initialSkipCount - 1].type.type, m_tags ) );
-  std::string dataName =
-    startLowerCase( stripPrefix( commandIt->second.params[nonConstPointerParamIndices[0]].name, "p" ) );
-  std::string enter, leave;
-  std::tie( enter, leave ) = generateProtection( commandIt->second.referencedIn );
 
-  std::string const singularDeclarationTemplate =
-    R"(
-${enter}    template <typename T>
-    VULKAN_HPP_NODISCARD T ${commandName}( ${argumentList} ) const;
-${leave})";
-
-  std::string declaration = replaceWithMap( singularDeclarationTemplate,
-                                            { { "argumentList", argumentListDeclaration },
-                                              { "commandName", commandName },
-                                              { "enter", enter },
-                                              { "leave", leave } } );
-
-  std::string const singularDefinitionTemplate =
-    R"(
-${enter}  template <typename T>
+  if ( definition )
+  {
+    std::string const singularDefinitionTemplate =
+      R"(
+  template <typename T>
   VULKAN_HPP_NODISCARD T ${className}::${commandName}( ${argumentList} ) const
   {
     T ${dataName};
@@ -8666,63 +8762,60 @@ ${enter}  template <typename T>
     }
     return ${dataName};
   }
-${leave})";
+)";
 
-  std::string definition =
-    replaceWithMap( singularDefinitionTemplate,
-                    { { "argumentList", argumentListDefinition },
-                      { "callArguments", callArguments },
-                      { "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) },
-                      { "commandName", commandName },
-                      { "dataName", dataName },
-                      { "enter", enter },
-                      { "failureCheck", constructFailureCheck( commandIt->second.successCodes ) },
-                      { "leave", leave },
-                      { "vkCommand", commandIt->first } } );
+    std::string callArguments = constructCallArgumentsEnhanced(
+      commandIt->second.params, initialSkipCount, false, singularParams, nonConstPointerParamIndices, true );
+    std::string dataName =
+      startLowerCase( stripPrefix( commandIt->second.params[nonConstPointerParamIndices[0]].name, "p" ) );
 
-  return std::make_pair( declaration, definition );
+    return replaceWithMap(
+      singularDefinitionTemplate,
+      { { "argumentList", argumentList },
+        { "callArguments", callArguments },
+        { "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) },
+        { "commandName", commandName },
+        { "dataName", dataName },
+        { "failureCheck", constructFailureCheck( commandIt->second.successCodes ) },
+        { "vkCommand", commandIt->first } } );
+  }
+  else
+  {
+    std::string const singularDeclarationTemplate =
+      R"(
+    template <typename T>
+    VULKAN_HPP_NODISCARD T ${commandName}( ${argumentList} ) const;
+)";
+
+    return replaceWithMap( singularDeclarationTemplate,
+                           {
+                             { "argumentList", argumentList },
+                             { "commandName", commandName },
+                           } );
+  }
 }
 
-std::pair<std::string, std::string> VulkanHppGenerator::constructRAIIHandleMemberFunctionResultSingleGetVectorSingular(
+std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionResultSingleGetVectorSingular(
   std::map<std::string, CommandData>::const_iterator commandIt,
   size_t                                             initialSkipCount,
   std::map<size_t, size_t> const &                   vectorParamIndices,
-  size_t                                             returnParamIndex ) const
+  size_t                                             returnParamIndex,
+  bool                                               definition ) const
 {
   std::set<size_t> skippedParameters = determineSkippedParams(
     commandIt->second.params, initialSkipCount, vectorParamIndices, { returnParamIndex }, true );
-  std::set<size_t> singularParams          = determineSingularParams( returnParamIndex, vectorParamIndices );
-  std::string      argumentListDeclaration = constructArgumentListEnhanced(
-    commandIt->second.params, skippedParameters, singularParams, false, false, false, false );
-  std::string argumentListDefinition = constructArgumentListEnhanced(
-    commandIt->second.params, skippedParameters, singularParams, true, false, false, false );
-  std::string callArguments = constructCallArgumentsEnhanced(
-    commandIt->second.params, initialSkipCount, false, singularParams, { returnParamIndex }, true );
+  std::set<size_t> singularParams = determineSingularParams( returnParamIndex, vectorParamIndices );
+  std::string      argumentList   = constructArgumentListEnhanced(
+    commandIt->second.params, skippedParameters, singularParams, definition, false, false, false );
   std::string commandName = stripPluralS(
     determineCommandName( commandIt->first, commandIt->second.params[initialSkipCount - 1].type.type, m_tags ) );
-  std::string enter, leave;
-  std::tie( enter, leave ) = generateProtection( commandIt->second.referencedIn );
-  std::string vectorElementName =
-    stripPluralS( startLowerCase( stripPrefix( commandIt->second.params[returnParamIndex].name, "p" ) ) );
   std::string vectorElementType = commandIt->second.params[returnParamIndex].type.type;
 
-  std::string const declarationTemplate =
-    R"(
-${enter}    VULKAN_HPP_NODISCARD ${vectorElementType} ${commandName}( ${argumentList} ) const;
-${leave})";
-
-  std::string declaration = replaceWithMap( declarationTemplate,
-                                            {
-                                              { "argumentList", argumentListDeclaration },
-                                              { "commandName", commandName },
-                                              { "enter", enter },
-                                              { "leave", leave },
-                                              { "vectorElementType", vectorElementType },
-                                            } );
-
-  std::string const definitionTemplate =
-    R"(
-${enter}  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ${vectorElementType} ${className}::${commandName}( ${argumentList} ) const
+  if ( definition )
+  {
+    std::string const definitionTemplate =
+      R"(
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ${vectorElementType} ${className}::${commandName}( ${argumentList} ) const
   {${functionPointerCheck}
     ${vectorElementType} ${vectorElementName};
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->${vkCommand}( ${callArguments} ) );
@@ -8732,125 +8825,120 @@ ${enter}  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ${vectorElementType} ${classNam
     }
     return ${vectorElementName};
   }
-${leave})";
+)";
 
-  std::string definition = replaceWithMap(
-    definitionTemplate,
-    { { "argumentList", argumentListDefinition },
-      { "callArguments", callArguments },
-      { "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) },
-      { "commandName", commandName },
-      { "enter", enter },
-      { "failureCheck", constructFailureCheck( commandIt->second.successCodes ) },
-      { "functionPointerCheck", constructFunctionPointerCheck( commandIt->first, commandIt->second.referencedIn ) },
-      { "leave", leave },
-      { "vectorElementName", vectorElementName },
-      { "vectorElementType", vectorElementType },
-      { "vkCommand", commandIt->first } } );
+    std::string callArguments = constructCallArgumentsEnhanced(
+      commandIt->second.params, initialSkipCount, false, singularParams, { returnParamIndex }, true );
+    std::string vectorElementName =
+      stripPluralS( startLowerCase( stripPrefix( commandIt->second.params[returnParamIndex].name, "p" ) ) );
 
-  return std::make_pair( declaration, definition );
-}
-
-std::pair<std::string, std::string> VulkanHppGenerator::constructRAIIHandleMemberFunctionResultSingleNoErrors(
-  std::map<std::string, CommandData>::const_iterator commandIt,
-  size_t                                             initialSkipCount,
-  std::map<size_t, size_t> const &                   vectorParamIndices ) const
-{
-  std::set<size_t> skippedParameters =
-    determineSkippedParams( commandIt->second.params, initialSkipCount, vectorParamIndices, {}, false );
-  std::string argumentListDeclaration =
-    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, false, false, false, false );
-  std::string argumentListDefinition =
-    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, true, false, false, false );
-  std::string callArguments =
-    constructCallArgumentsEnhanced( commandIt->second.params, initialSkipCount, false, {}, {}, true );
-  std::string commandName =
-    determineCommandName( commandIt->first, commandIt->second.params[initialSkipCount - 1].type.type, m_tags );
-  std::string enter, leave;
-  std::tie( enter, leave ) = generateProtection( commandIt->second.referencedIn );
-
-  std::pair<bool, std::map<size_t, std::vector<size_t>>> vectorSizeCheck = needsVectorSizeCheck( vectorParamIndices );
-  std::string                                            vectorSizeCheckString =
-    vectorSizeCheck.first
-                                                 ? constructRAIIHandleVectorSizeCheck(
-          commandIt->first, commandIt->second, initialSkipCount, vectorSizeCheck.second, skippedParameters )
-                                                 : "";
-
-  std::string const declarationTemplate =
-    R"(
-${enter}    void ${commandName}( ${argumentList} ) const VULKAN_HPP_NOEXCEPT;
-${leave})";
-
-  std::string declaration = replaceWithMap( declarationTemplate,
-                                            { { "argumentList", argumentListDeclaration },
-                                              { "commandName", commandName },
-                                              { "enter", enter },
-                                              { "leave", leave } } );
-
-  std::string const definitionTemplate =
-    R"(
-${enter}  VULKAN_HPP_INLINE void ${className}::${commandName}( ${argumentList} ) const VULKAN_HPP_NOEXCEPT
-  {${functionPointerCheck}${vectorSizeCheck}
-    getDispatcher()->${vkCommand}( ${callArguments} );
+    return replaceWithMap(
+      definitionTemplate,
+      { { "argumentList", argumentList },
+        { "callArguments", callArguments },
+        { "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) },
+        { "commandName", commandName },
+        { "failureCheck", constructFailureCheck( commandIt->second.successCodes ) },
+        { "functionPointerCheck", constructFunctionPointerCheck( commandIt->first, commandIt->second.referencedIn ) },
+        { "vectorElementName", vectorElementName },
+        { "vectorElementType", vectorElementType },
+        { "vkCommand", commandIt->first } } );
   }
-${leave})";
+  else
+  {
+    std::string const declarationTemplate =
+      R"(
+    VULKAN_HPP_NODISCARD ${vectorElementType} ${commandName}( ${argumentList} ) const;
+)";
 
-  std::string definition = replaceWithMap(
-    definitionTemplate,
-    { { "argumentList", argumentListDefinition },
-      { "callArguments", callArguments },
-      { "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) },
-      { "commandName", commandName },
-      { "enter", enter },
-      { "functionPointerCheck", constructFunctionPointerCheck( commandIt->first, commandIt->second.referencedIn ) },
-      { "leave", leave },
-      { "vectorSizeCheck", vectorSizeCheckString },
-      { "vkCommand", commandIt->first } } );
-
-  return std::make_pair( declaration, definition );
+    return replaceWithMap( declarationTemplate,
+                           {
+                             { "argumentList", argumentList },
+                             { "commandName", commandName },
+                             { "vectorElementType", vectorElementType },
+                           } );
+  }
 }
 
-std::pair<std::string, std::string> VulkanHppGenerator::constructRAIIHandleMemberFunctionResultSingleGetValue(
+std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionResultSingleNoErrors(
   std::map<std::string, CommandData>::const_iterator commandIt,
   size_t                                             initialSkipCount,
   std::map<size_t, size_t> const &                   vectorParamIndices,
-  std::vector<size_t> const &                        nonConstPointerParamIndices ) const
+  bool                                               definition ) const
+{
+  std::set<size_t> skippedParameters =
+    determineSkippedParams( commandIt->second.params, initialSkipCount, vectorParamIndices, {}, false );
+  std::string argumentList =
+    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, definition, false, false, false );
+  std::string commandName =
+    determineCommandName( commandIt->first, commandIt->second.params[initialSkipCount - 1].type.type, m_tags );
+
+  if ( definition )
+  {
+    std::string const definitionTemplate =
+      R"(
+  VULKAN_HPP_INLINE void ${className}::${commandName}( ${argumentList} ) const VULKAN_HPP_NOEXCEPT
+  {${functionPointerCheck}${vectorSizeCheck}
+    getDispatcher()->${vkCommand}( ${callArguments} );
+  }
+)";
+
+    std::string callArguments =
+      constructCallArgumentsEnhanced( commandIt->second.params, initialSkipCount, false, {}, {}, true );
+    std::pair<bool, std::map<size_t, std::vector<size_t>>> vectorSizeCheck = needsVectorSizeCheck( vectorParamIndices );
+    std::string                                            vectorSizeCheckString =
+      vectorSizeCheck.first
+                                                   ? constructRAIIHandleVectorSizeCheck(
+            commandIt->first, commandIt->second, initialSkipCount, vectorSizeCheck.second, skippedParameters )
+                                                   : "";
+
+    return replaceWithMap(
+      definitionTemplate,
+      { { "argumentList", argumentList },
+        { "callArguments", callArguments },
+        { "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) },
+        { "commandName", commandName },
+        { "functionPointerCheck", constructFunctionPointerCheck( commandIt->first, commandIt->second.referencedIn ) },
+        { "vectorSizeCheck", vectorSizeCheckString },
+        { "vkCommand", commandIt->first } } );
+  }
+  else
+  {
+    std::string const declarationTemplate =
+      R"(
+    void ${commandName}( ${argumentList} ) const VULKAN_HPP_NOEXCEPT;
+)";
+
+    return replaceWithMap( declarationTemplate,
+                           {
+                             { "argumentList", argumentList },
+                             { "commandName", commandName },
+                           } );
+  }
+}
+
+std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionResultSingleGetValue(
+  std::map<std::string, CommandData>::const_iterator commandIt,
+  size_t                                             initialSkipCount,
+  std::map<size_t, size_t> const &                   vectorParamIndices,
+  std::vector<size_t> const &                        nonConstPointerParamIndices,
+  bool                                               definition ) const
 {
   assert( nonConstPointerParamIndices.size() == 1 );
 
   std::set<size_t> skippedParameters = determineSkippedParams(
     commandIt->second.params, initialSkipCount, vectorParamIndices, nonConstPointerParamIndices, false );
-  std::string argumentListDeclaration =
-    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, false, false, false, false );
-  std::string argumentListDefinition =
-    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, true, false, false, false );
-  std::string callArguments = constructCallArgumentsEnhanced(
-    commandIt->second.params, initialSkipCount, false, {}, nonConstPointerParamIndices, true );
+  std::string argumentList =
+    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, definition, false, false, false );
   std::string commandName = determineCommandName(
     commandIt->first, initialSkipCount ? commandIt->second.params[initialSkipCount - 1].type.type : "", m_tags );
-  std::string enter, leave;
-  std::tie( enter, leave ) = generateProtection( commandIt->second.referencedIn );
   std::string returnType = stripPostfix( commandIt->second.params[nonConstPointerParamIndices[0]].type.compose(), "*" );
-  std::string valueName =
-    startLowerCase( stripPrefix( commandIt->second.params[nonConstPointerParamIndices[0]].name, "p" ) );
 
-  std::string const declarationTemplate =
-    R"(
-${enter}  VULKAN_HPP_NODISCARD ${returnType} ${commandName}( ${argumentList} ) const;
-${leave})";
-
-  std::string declaration = replaceWithMap( declarationTemplate,
-                                            {
-                                              { "argumentList", argumentListDeclaration },
-                                              { "commandName", commandName },
-                                              { "enter", enter },
-                                              { "leave", leave },
-                                              { "returnType", returnType },
-                                            } );
-
-  std::string const definitionTemplate =
-    R"(
-${enter}  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ${returnType} ${className}::${commandName}( ${argumentList} ) const
+  if ( definition )
+  {
+    std::string const definitionTemplate =
+      R"(
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ${returnType} ${className}::${commandName}( ${argumentList} ) const
   {${functionPointerCheck}
     ${returnType} ${valueName};
     VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->${vkCommand}( ${callArguments} ) );
@@ -8860,62 +8948,40 @@ ${enter}  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ${returnType} ${className}::${c
     }
     return ${valueName};
   }
-${leave})";
+)";
 
-  std::string definition = replaceWithMap(
-    definitionTemplate,
-    { { "argumentList", argumentListDefinition },
-      { "callArguments", callArguments },
-      { "className",
-        initialSkipCount ? stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) : "Context" },
-      { "commandName", commandName },
-      { "enter", enter },
-      { "failureCheck", constructFailureCheck( commandIt->second.successCodes ) },
-      { "functionPointerCheck", constructFunctionPointerCheck( commandIt->first, commandIt->second.referencedIn ) },
-      { "leave", leave },
-      { "valueName", valueName },
-      { "returnType", returnType },
-      { "vkCommand", commandIt->first } } );
+    std::string callArguments = constructCallArgumentsEnhanced(
+      commandIt->second.params, initialSkipCount, false, {}, nonConstPointerParamIndices, true );
+    std::string valueName =
+      startLowerCase( stripPrefix( commandIt->second.params[nonConstPointerParamIndices[0]].name, "p" ) );
 
-  return std::make_pair( declaration, definition );
-}
-
-void VulkanHppGenerator::constructRAIIHandleMemberFunction( std::string &                 functionDeclarations,
-                                                            std::string &                 functionDefinitions,
-                                                            std::string const &           command,
-                                                            size_t                        initialSkipCount,
-                                                            std::set<std::string> const & specialFunctions ) const
-{
-  if ( specialFunctions.find( command ) == specialFunctions.end() )
+    return replaceWithMap(
+      definitionTemplate,
+      { { "argumentList", argumentList },
+        { "callArguments", callArguments },
+        { "className",
+          initialSkipCount ? stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" )
+                           : "Context" },
+        { "commandName", commandName },
+        { "failureCheck", constructFailureCheck( commandIt->second.successCodes ) },
+        { "functionPointerCheck", constructFunctionPointerCheck( commandIt->first, commandIt->second.referencedIn ) },
+        { "valueName", valueName },
+        { "returnType", returnType },
+        { "vkCommand", commandIt->first } } );
+  }
+  else
   {
-    bool commandConstructed = false;
-    auto commandIt          = m_commands.find( command );
-    assert( commandIt != m_commands.end() );
+    std::string const declarationTemplate =
+      R"(
+  VULKAN_HPP_NODISCARD ${returnType} ${commandName}( ${argumentList} ) const;
+)";
 
-    if ( commandIt->second.returnType == "VkResult" )
-    {
-      commandConstructed = constructRAIIHandleMemberFunctionResult(
-        functionDeclarations, functionDefinitions, commandIt, initialSkipCount );
-    }
-    else
-    {
-      assert( commandIt->second.successCodes.empty() && commandIt->second.errorCodes.empty() );
-      if ( commandIt->second.returnType == "void" )
-      {
-        commandConstructed = constructRAIIHandleMemberFunctionVoid(
-          functionDeclarations, functionDefinitions, commandIt, initialSkipCount );
-      }
-      else
-      {
-        commandConstructed = constructRAIIHandleMemberFunctionValue(
-          functionDeclarations, functionDefinitions, commandIt, initialSkipCount );
-      }
-    }
-
-    if ( !commandConstructed )
-    {
-      throw std::runtime_error( "Never encountered a function like <" + commandIt->first + "> !" );
-    }
+    return replaceWithMap( declarationTemplate,
+                           {
+                             { "argumentList", argumentList },
+                             { "commandName", commandName },
+                             { "returnType", returnType },
+                           } );
   }
 }
 
@@ -8992,84 +9058,77 @@ ${leave})";
   return std::make_pair( declaration, definition );
 }
 
-bool VulkanHppGenerator::constructRAIIHandleMemberFunctionResult(
-  std::string &                                      functionDeclarations,
-  std::string &                                      functionDefinitions,
-  std::map<std::string, CommandData>::const_iterator commandIt,
-  size_t                                             initialSkipCount ) const
+std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionResult(
+  std::map<std::string, CommandData>::const_iterator commandIt, size_t initialSkipCount, bool definition ) const
 {
   // as the returnType is "VkResult", there has to be at least one success code
   assert( !commandIt->second.successCodes.empty() );
 
-  bool                commandConstructed = false;
   std::vector<size_t> returnParamIndices = determineNonConstPointerParamIndices( commandIt->second.params );
-  std::string         declaration, definition;
+  std::string         function;
   switch ( returnParamIndices.size() )
   {
-    case 0:
-      std::tie( commandConstructed, declaration, definition ) =
-        constructRAIIHandleMemberFunctionResult0Return( commandIt, initialSkipCount );
-      break;
+    case 0: function = constructRAIIHandleMemberFunctionResult0Return( commandIt, initialSkipCount, definition ); break;
     case 1:
-      std::tie( commandConstructed, declaration, definition ) =
-        constructRAIIHandleMemberFunctionResult1Return( commandIt, initialSkipCount, returnParamIndices[0] );
+      function = constructRAIIHandleMemberFunctionResult1Return(
+        commandIt, initialSkipCount, returnParamIndices[0], definition );
       break;
     case 2:
-      std::tie( commandConstructed, declaration, definition ) =
-        constructRAIIHandleMemberFunctionResult2Return( commandIt, initialSkipCount, returnParamIndices );
+      function =
+        constructRAIIHandleMemberFunctionResult2Return( commandIt, initialSkipCount, returnParamIndices, definition );
       break;
     case 3:
-      std::tie( commandConstructed, declaration, definition ) =
-        constructRAIIHandleMemberFunctionResult3Return( commandIt, initialSkipCount, returnParamIndices );
+      function =
+        constructRAIIHandleMemberFunctionResult3Return( commandIt, initialSkipCount, returnParamIndices, definition );
       break;
   }
-  functionDeclarations += declaration;
-  functionDefinitions += definition;
-  return commandConstructed;
+  return function;
 }
 
-std::tuple<bool, std::string, std::string> VulkanHppGenerator::constructRAIIHandleMemberFunctionResult0Return(
-  std::map<std::string, CommandData>::const_iterator commandIt, size_t initialSkipCount ) const
+std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionResult0Return(
+  std::map<std::string, CommandData>::const_iterator commandIt, size_t initialSkipCount, bool definition ) const
 {
-  std::string              declaration, definition;
+  std::string              function;
   std::map<size_t, size_t> vectorParamIndices = determineVectorParamIndicesNew( commandIt->second.params );
   if ( commandIt->second.errorCodes.empty() )
   {
     if ( commandIt->second.successCodes.size() == 1 )
     {
-      std::tie( declaration, definition ) =
-        constructRAIIHandleMemberFunctionResultSingleNoErrors( commandIt, initialSkipCount, vectorParamIndices );
+      function = constructRAIIHandleMemberFunctionResultSingleNoErrors(
+        commandIt, initialSkipCount, vectorParamIndices, definition );
     }
     else
     {
-      std::tie( declaration, definition ) =
-        constructRAIIHandleMemberFunctionResultMultiNoErrors( commandIt, initialSkipCount, vectorParamIndices );
+      function = constructRAIIHandleMemberFunctionResultMultiNoErrors(
+        commandIt, initialSkipCount, vectorParamIndices, definition );
     }
   }
   else
   {
     if ( commandIt->second.successCodes.size() == 1 )
     {
-      std::tie( declaration, definition ) =
-        constructRAIIHandleMemberFunctionResultSingle( commandIt, initialSkipCount, vectorParamIndices );
+      function =
+        constructRAIIHandleMemberFunctionResultSingle( commandIt, initialSkipCount, vectorParamIndices, definition );
     }
     else
     {
-      std::tie( declaration, definition ) =
-        constructRAIIHandleMemberFunctionResultMulti( commandIt, initialSkipCount, vectorParamIndices );
+      function =
+        constructRAIIHandleMemberFunctionResultMulti( commandIt, initialSkipCount, vectorParamIndices, definition );
     }
   }
-  return std::make_tuple( true, declaration, definition );
+  return function;
 }
 
-std::tuple<bool, std::string, std::string> VulkanHppGenerator::constructRAIIHandleMemberFunctionResult1Return(
-  std::map<std::string, CommandData>::const_iterator commandIt, size_t initialSkipCount, size_t returnParamIndex ) const
+std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionResult1Return(
+  std::map<std::string, CommandData>::const_iterator commandIt,
+  size_t                                             initialSkipCount,
+  size_t                                             returnParamIndex,
+  bool                                               definition ) const
 {
   // one return parameter (and it's not a handle, that would be a constructor)
   assert( !isHandleType( commandIt->second.params[returnParamIndex].type.type ) );
 
-  bool                     commandConstructed = false;
-  std::string              declaration, definition;
+  std::string              function;
   std::map<size_t, size_t> vectorParamIndices  = determineVectorParamIndicesNew( commandIt->second.params );
   auto                     returnVectorParamIt = vectorParamIndices.find( returnParamIndex );
   if ( returnVectorParamIt == vectorParamIndices.end() )
@@ -9081,15 +9140,14 @@ std::tuple<bool, std::string, std::string> VulkanHppGenerator::constructRAIIHand
     {
       if ( commandIt->second.successCodes.size() == 1 )
       {
-        std::tie( declaration, definition ) = constructRAIIHandleMemberFunctionResultSingleGetValue(
-          commandIt, initialSkipCount, vectorParamIndices, { returnParamIndex } );
+        function = constructRAIIHandleMemberFunctionResultSingleGetValue(
+          commandIt, initialSkipCount, vectorParamIndices, { returnParamIndex }, definition );
       }
       else
       {
-        std::tie( declaration, definition ) = constructRAIIHandleMemberFunctionResultMultiGetValue(
-          commandIt, initialSkipCount, vectorParamIndices, { returnParamIndex } );
+        function = constructRAIIHandleMemberFunctionResultMultiGetValue(
+          commandIt, initialSkipCount, vectorParamIndices, { returnParamIndex }, definition );
       }
-      commandConstructed = true;
     }
   }
   else
@@ -9106,45 +9164,29 @@ std::tuple<bool, std::string, std::string> VulkanHppGenerator::constructRAIIHand
         // the return parameter is of type void
         if ( commandIt->second.successCodes.size() == 1 )
         {
-          std::tie( declaration, definition ) = constructRAIIHandleMemberFunctionResultSingleGetVectorOfVoid(
-            commandIt, initialSkipCount, vectorParamIndices, { returnParamIndex } );
-
-          std::string singularDeclaration, singularDefinition;
-          std::tie( singularDeclaration, singularDefinition ) =
-            constructRAIIHandleMemberFunctionResultSingleGetVectorOfVoidSingular(
-              commandIt, initialSkipCount, vectorParamIndices, { returnParamIndex } );
-          declaration += singularDeclaration;
-          definition += singularDefinition;
+          function = constructRAIIHandleMemberFunctionResultSingleGetVectorOfVoid(
+            commandIt, initialSkipCount, vectorParamIndices, { returnParamIndex }, definition );
+          function += constructRAIIHandleMemberFunctionResultSingleGetVectorOfVoidSingular(
+            commandIt, initialSkipCount, vectorParamIndices, { returnParamIndex }, definition );
         }
         else
         {
-          std::tie( declaration, definition ) = constructRAIIHandleMemberFunctionResultMultiGetVectorOfVoid(
-            commandIt, initialSkipCount, vectorParamIndices, { returnParamIndex } );
+          function = constructRAIIHandleMemberFunctionResultMultiGetVectorOfVoid(
+            commandIt, initialSkipCount, vectorParamIndices, { returnParamIndex }, definition );
 
-          std::string singularDeclaration, singularDefinition;
-          std::tie( singularDeclaration, singularDefinition ) =
-            constructRAIIHandleMemberFunctionResultMultiGetVectorOfVoidSingular(
-              commandIt, initialSkipCount, vectorParamIndices, { returnParamIndex } );
-          declaration += singularDeclaration;
-          definition += singularDefinition;
+          function += constructRAIIHandleMemberFunctionResultMultiGetVectorOfVoidSingular(
+            commandIt, initialSkipCount, vectorParamIndices, { returnParamIndex }, definition );
         }
-        commandConstructed = true;
       }
       else
       {
         // the return parameter is of a concrete type
         if ( commandIt->second.successCodes.size() == 1 )
         {
-          std::tie( declaration, definition ) = constructRAIIHandleMemberFunctionResultSingleGetVector(
-            commandIt, initialSkipCount, vectorParamIndices, returnParamIndex );
-
-          std::string singularDeclaration, singularDefinition;
-          std::tie( singularDeclaration, singularDefinition ) =
-            constructRAIIHandleMemberFunctionResultSingleGetVectorSingular(
-              commandIt, initialSkipCount, vectorParamIndices, returnParamIndex );
-          declaration += singularDeclaration;
-          definition += singularDefinition;
-          commandConstructed = true;
+          function = constructRAIIHandleMemberFunctionResultSingleGetVector(
+            commandIt, initialSkipCount, vectorParamIndices, returnParamIndex, definition );
+          function += constructRAIIHandleMemberFunctionResultSingleGetVectorSingular(
+            commandIt, initialSkipCount, vectorParamIndices, returnParamIndex, definition );
         }
       }
     }
@@ -9152,7 +9194,6 @@ std::tuple<bool, std::string, std::string> VulkanHppGenerator::constructRAIIHand
   if ( isStructureChainAnchor( commandIt->second.params[returnParamIndex].type.type ) )
   {
     // for StructureChain returns, add functions returning a StructureChain
-    commandConstructed = false;
     if ( returnVectorParamIt == vectorParamIndices.end() )
     {
       // as the returnType is "VkResult", there has to be at least one success code
@@ -9161,31 +9202,30 @@ std::tuple<bool, std::string, std::string> VulkanHppGenerator::constructRAIIHand
       {
         if ( commandIt->second.successCodes.size() == 1 )
         {
-          std::string chainDeclaration, chainDefinition;
-          std::tie( chainDeclaration, chainDefinition ) = constructRAIIHandleMemberFunctionResultSingleGetChain(
-            commandIt, initialSkipCount, vectorParamIndices, { returnParamIndex } );
-          declaration += chainDeclaration;
-          definition += chainDefinition;
-          commandConstructed = true;
+          function += constructRAIIHandleMemberFunctionResultSingleGetChain(
+            commandIt, initialSkipCount, vectorParamIndices, { returnParamIndex }, definition );
         }
       }
     }
+    else
+    {
+      throw std::runtime_error( "Never encountered a function like <" + commandIt->first + "> !" );
+    }
   }
-
-  return std::make_tuple( commandConstructed, declaration, definition );
+  return function;
 }
 
-std::tuple<bool, std::string, std::string> VulkanHppGenerator::constructRAIIHandleMemberFunctionResult2Return(
+std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionResult2Return(
   std::map<std::string, CommandData>::const_iterator commandIt,
   size_t                                             initialSkipCount,
-  std::vector<size_t> const &                        returnParamIndices ) const
+  std::vector<size_t> const &                        returnParamIndices,
+  bool                                               definition ) const
 {
   // two return parameters (and the first one is not a handle, that would be a constructor)
   assert( returnParamIndices.size() == 2 );
   assert( !isHandleType( commandIt->second.params[returnParamIndices[0]].type.type ) );
 
-  bool                     commandConstructed = false;
-  std::string              declaration, definition;
+  std::string              function;
   std::map<size_t, size_t> vectorParamIndices = determineVectorParamIndicesNew( commandIt->second.params );
   switch ( vectorParamIndices.size() )
   {
@@ -9205,9 +9245,8 @@ std::tuple<bool, std::string, std::string> VulkanHppGenerator::constructRAIIHand
                  ( commandIt->second.successCodes[0] == "VK_SUCCESS" ) &&
                  ( commandIt->second.successCodes[1] == "VK_INCOMPLETE" ) )
             {
-              std::tie( declaration, definition ) = constructRAIIHandleMemberFunctionResultEnumerate(
-                commandIt, initialSkipCount, vectorParamIndices, returnParamIndices );
-              commandConstructed = true;
+              function = constructRAIIHandleMemberFunctionResultEnumerate(
+                commandIt, initialSkipCount, vectorParamIndices, returnParamIndices, definition );
             }
           }
         }
@@ -9226,9 +9265,8 @@ std::tuple<bool, std::string, std::string> VulkanHppGenerator::constructRAIIHand
         {
           if ( commandIt->second.successCodes.size() == 1 )
           {
-            std::tie( declaration, definition ) = constructRAIIHandleMemberFunctionResultSingleGetVectorAndValue(
-              commandIt, initialSkipCount, vectorParamIndices, returnParamIndices );
-            commandConstructed = true;
+            function = constructRAIIHandleMemberFunctionResultSingleGetVectorAndValue(
+              commandIt, initialSkipCount, vectorParamIndices, returnParamIndices, definition );
           }
         }
       }
@@ -9236,21 +9274,21 @@ std::tuple<bool, std::string, std::string> VulkanHppGenerator::constructRAIIHand
   }
   if ( isStructureChainAnchor( commandIt->second.params[returnParamIndices[0]].type.type ) )
   {
-    commandConstructed = false;
+    throw std::runtime_error( "Never encountered a function like <" + commandIt->first + "> !" );
   }
-  return std::make_tuple( commandConstructed, declaration, definition );
+  return function;
 }
 
-std::tuple<bool, std::string, std::string> VulkanHppGenerator::constructRAIIHandleMemberFunctionResult3Return(
+std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionResult3Return(
   std::map<std::string, CommandData>::const_iterator commandIt,
   size_t                                             initialSkipCount,
-  std::vector<size_t> const &                        returnParamIndices ) const
+  std::vector<size_t> const &                        returnParamIndices,
+  bool                                               definition ) const
 {
   // three return parameters
   assert( returnParamIndices.size() == 3 );
 
-  bool                     commandConstructed = false;
-  std::string              declaration, definition;
+  std::string              function;
   std::map<size_t, size_t> vectorParamIndices = determineVectorParamIndicesNew( commandIt->second.params );
   if ( vectorParamIndices.size() == 2 )
   {
@@ -9275,9 +9313,8 @@ std::tuple<bool, std::string, std::string> VulkanHppGenerator::constructRAIIHand
         if ( ( commandIt->second.successCodes.size() == 2 ) && ( commandIt->second.successCodes[0] == "VK_SUCCESS" ) &&
              ( commandIt->second.successCodes[1] == "VK_INCOMPLETE" ) )
         {
-          std::tie( declaration, definition ) = constructRAIIHandleMemberFunctionResultEnumerateTwoVectors(
-            commandIt, initialSkipCount, vectorParamIndices, returnParamIndices );
-          commandConstructed = true;
+          function = constructRAIIHandleMemberFunctionResultEnumerateTwoVectors(
+            commandIt, initialSkipCount, vectorParamIndices, returnParamIndices, definition );
         }
       }
     }
@@ -9286,306 +9323,351 @@ std::tuple<bool, std::string, std::string> VulkanHppGenerator::constructRAIIHand
        isStructureChainAnchor( commandIt->second.params[returnParamIndices[1]].type.type ) ||
        isStructureChainAnchor( commandIt->second.params[returnParamIndices[2]].type.type ) )
   {
-    commandConstructed = true;
+    throw std::runtime_error( "Never encountered a function like <" + commandIt->first + "> !" );
   }
-  return std::make_tuple( commandConstructed, declaration, definition );
+  return function;
 }
 
-std::pair<std::string, std::string>
-  VulkanHppGenerator::constructRAIIHandleMemberFunctions( std::pair<std::string, HandleData> const & handle,
-                                                          std::set<std::string> const & specialFunctions ) const
+std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionDeclarations(
+  std::pair<std::string, HandleData> const & handle, std::set<std::string> const & specialFunctions ) const
 {
-  std::string functionDeclarations, functionDefinitions;
-  for ( auto const & command : handle.second.commands )
+  std::string           functionDeclarations;
+  std::set<std::string> listedCommands;  // some commands are listed with more than one extension !
+  for ( auto const & feature : m_features )
   {
-    constructRAIIHandleMemberFunction(
-      functionDeclarations, functionDefinitions, command, handle.first.empty() ? 0 : 1, specialFunctions );
+    std::vector<std::string> firstLevelCommands, secondLevelCommands;
+
+    for ( auto const & command : feature.second.commands )
+    {
+      if ( specialFunctions.find( command ) == specialFunctions.end() )
+      {
+        if ( handle.second.commands.find( command ) != handle.second.commands.end() )
+        {
+          assert( listedCommands.find( command ) == listedCommands.end() );
+          listedCommands.insert( command );
+          firstLevelCommands.push_back( command );
+        }
+        else if ( handle.second.secondLevelCommands.find( command ) != handle.second.secondLevelCommands.end() )
+        {
+          assert( listedCommands.find( command ) == listedCommands.end() );
+          listedCommands.insert( command );
+          assert( !handle.first.empty() );
+          secondLevelCommands.push_back( command );
+        }
+      }
+    }
+    if ( !firstLevelCommands.empty() || !secondLevelCommands.empty() )
+    {
+      functionDeclarations += "\n  //=== " + feature.first + " ===\n";
+      for ( auto const & command : firstLevelCommands )
+      {
+        functionDeclarations +=
+          constructRAIIHandleMemberFunction( command, handle.first.empty() ? 0 : 1, specialFunctions, false );
+      }
+      for ( auto const & command : secondLevelCommands )
+      {
+        assert( !handle.first.empty() );
+        functionDeclarations += constructRAIIHandleMemberFunction( command, 2, specialFunctions, false );
+      }
+    }
   }
-  for ( auto const & command : handle.second.secondLevelCommands )
+
+  for ( auto const & extIt : m_extensionsByNumber )
   {
-    assert( !handle.first.empty() );
-    constructRAIIHandleMemberFunction( functionDeclarations, functionDefinitions, command, 2, specialFunctions );
+    std::vector<std::string> firstLevelCommands, secondLevelCommands;
+    for ( auto const & command : extIt.second->second.commands )
+    {
+      if ( ( specialFunctions.find( command ) == specialFunctions.end() ) &&
+           ( listedCommands.find( command ) == listedCommands.end() ) )
+      {
+        if ( handle.second.commands.find( command ) != handle.second.commands.end() )
+        {
+          listedCommands.insert( command );
+          firstLevelCommands.push_back( command );
+        }
+        else if ( handle.second.secondLevelCommands.find( command ) != handle.second.secondLevelCommands.end() )
+        {
+          listedCommands.insert( command );
+          secondLevelCommands.push_back( command );
+        }
+      }
+    }
+    if ( !firstLevelCommands.empty() || !secondLevelCommands.empty() )
+    {
+      std::string enter, leave;
+      if ( extIt.second->first != m_types.find( handle.first )->second.referencedIn )
+      {
+        std::tie( enter, leave ) = generateProtection( extIt.second->first );
+        if ( !enter.empty() )
+        {
+          enter = "\n" + enter;
+          assert( endsWith( enter, "\n" ) );
+          enter.resize( enter.size() - strlen( "\n" ) );
+        }
+      }
+      functionDeclarations += enter + "\n  //=== " + extIt.second->first + " ===\n";
+      for ( auto const & command : firstLevelCommands )
+      {
+        functionDeclarations +=
+          constructRAIIHandleMemberFunction( command, handle.first.empty() ? 0 : 1, specialFunctions, false );
+      }
+      for ( auto const & command : secondLevelCommands )
+      {
+        assert( !handle.first.empty() );
+        functionDeclarations += constructRAIIHandleMemberFunction( command, 2, specialFunctions, false );
+      }
+      functionDeclarations += leave;
+    }
   }
-  return std::make_pair( functionDeclarations, functionDefinitions );
+  return functionDeclarations;
 }
 
-std::pair<std::string, std::string> VulkanHppGenerator::constructRAIIHandleMemberFunctionType(
+std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionType(
   std::map<std::string, CommandData>::const_iterator commandIt,
   size_t                                             initialSkipCount,
-  std::map<size_t, size_t> const &                   vectorParamIndices ) const
+  std::map<size_t, size_t> const &                   vectorParamIndices,
+  bool                                               definition ) const
 {
   std::set<size_t> skippedParameters =
     determineSkippedParams( commandIt->second.params, initialSkipCount, vectorParamIndices, {}, false );
-  std::string argumentListDeclaration =
-    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, false, false, false, false );
-  std::string argumentListDefinition =
-    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, true, false, false, false );
-  std::string callArguments =
-    constructCallArgumentsEnhanced( commandIt->second.params, initialSkipCount, false, {}, {}, true );
+  std::string argumentList =
+    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, definition, false, false, false );
   std::string commandName =
     determineCommandName( commandIt->first, commandIt->second.params[initialSkipCount - 1].type.type, m_tags );
-  std::string enter, leave;
-  std::tie( enter, leave ) = generateProtection( commandIt->second.referencedIn );
-  std::string                                            returnType = namespacedType( commandIt->second.returnType );
-  std::pair<bool, std::map<size_t, std::vector<size_t>>> vectorSizeCheck = needsVectorSizeCheck( vectorParamIndices );
-  std::string                                            vectorSizeCheckString =
-    vectorSizeCheck.first
-                                                 ? constructVectorSizeCheck(
-          commandIt->first, commandIt->second, initialSkipCount, vectorSizeCheck.second, skippedParameters )
-                                                 : "";
+  std::string returnType = namespacedType( commandIt->second.returnType );
 
-  std::string const declarationTemplate =
-    R"(
-${enter}  VULKAN_HPP_NODISCARD ${returnType} ${commandName}( ${argumentList} ) const VULKAN_HPP_NOEXCEPT;
-${leave})";
-
-  std::string declaration = replaceWithMap( declarationTemplate,
-                                            {
-                                              { "argumentList", argumentListDeclaration },
-                                              { "commandName", commandName },
-                                              { "enter", enter },
-                                              { "leave", leave },
-                                              { "returnType", returnType },
-                                            } );
-
-  std::string const definitionTemplate =
-    R"(
-${enter}  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ${returnType} ${className}::${commandName}( ${argumentList} ) const VULKAN_HPP_NOEXCEPT
+  if ( definition )
+  {
+    std::string const definitionTemplate =
+      R"(
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ${returnType} ${className}::${commandName}( ${argumentList} ) const VULKAN_HPP_NOEXCEPT
   {${functionPointerCheck}${vectorSizeCheck}
     return getDispatcher()->${vkCommand}( ${callArguments} );
   }
-${leave})";
+)";
 
-  std::string definition = replaceWithMap(
-    definitionTemplate,
-    { { "argumentList", argumentListDefinition },
-      { "callArguments", callArguments },
-      { "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) },
-      { "commandName", commandName },
-      { "enter", enter },
-      { "functionPointerCheck", constructFunctionPointerCheck( commandIt->first, commandIt->second.referencedIn ) },
-      { "leave", leave },
-      { "returnType", returnType },
-      { "vectorSizeCheck", vectorSizeCheckString },
-      { "vkCommand", commandIt->first } } );
+    std::string callArguments =
+      constructCallArgumentsEnhanced( commandIt->second.params, initialSkipCount, false, {}, {}, true );
+    std::pair<bool, std::map<size_t, std::vector<size_t>>> vectorSizeCheck = needsVectorSizeCheck( vectorParamIndices );
+    std::string                                            vectorSizeCheckString =
+      vectorSizeCheck.first
+                                                   ? constructVectorSizeCheck(
+            commandIt->first, commandIt->second, initialSkipCount, vectorSizeCheck.second, skippedParameters )
+                                                   : "";
 
-  return std::make_pair( declaration, definition );
-}
-
-std::pair<std::string, std::string> VulkanHppGenerator::constructRAIIHandleMemberFunctionVkType(
-  std::map<std::string, CommandData>::const_iterator commandIt,
-  size_t                                             initialSkipCount,
-  std::map<size_t, size_t> const &                   vectorParamIndices ) const
-{
-  std::set<size_t> skippedParameters =
-    determineSkippedParams( commandIt->second.params, initialSkipCount, vectorParamIndices, {}, false );
-  std::string argumentListDeclaration =
-    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, false, false, false, false );
-  std::string argumentListDefinition =
-    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, true, false, false, false );
-  std::string callArguments =
-    constructCallArgumentsEnhanced( commandIt->second.params, initialSkipCount, false, {}, {}, true );
-  std::string commandName =
-    determineCommandName( commandIt->first, commandIt->second.params[initialSkipCount - 1].type.type, m_tags );
-  std::string enter, leave;
-  std::tie( enter, leave ) = generateProtection( commandIt->second.referencedIn );
-  std::string returnType   = namespacedType( commandIt->second.returnType );
-
-  std::pair<bool, std::map<size_t, std::vector<size_t>>> vectorSizeCheck = needsVectorSizeCheck( vectorParamIndices );
-  std::string                                            vectorSizeCheckString =
-    vectorSizeCheck.first
-                                                 ? constructRAIIHandleVectorSizeCheck(
-          commandIt->first, commandIt->second, initialSkipCount, vectorSizeCheck.second, skippedParameters )
-                                                 : "";
-
-  std::string const declarationTemplate =
-    R"(
-${enter}  VULKAN_HPP_NODISCARD ${returnType} ${commandName}( ${argumentList} ) const VULKAN_HPP_NOEXCEPT;
-${leave})";
-
-  std::string declaration = replaceWithMap( declarationTemplate,
-                                            {
-                                              { "argumentList", argumentListDeclaration },
-                                              { "commandName", commandName },
-                                              { "enter", enter },
-                                              { "leave", leave },
-                                              { "returnType", returnType },
-                                            } );
-
-  std::string const definitionTemplate =
-    R"(
-${enter}  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ${returnType} ${className}::${commandName}( ${argumentList} ) const VULKAN_HPP_NOEXCEPT
-  {${functionPointerCheck}${vectorSizeCheck}
-    return static_cast<${returnType}>( getDispatcher()->${vkCommand}( ${callArguments} ) );
-  }
-${leave})";
-
-  std::string definition = replaceWithMap(
-    definitionTemplate,
-    { { "argumentList", argumentListDefinition },
-      { "callArguments", callArguments },
-      { "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) },
-      { "commandName", commandName },
-      { "enter", enter },
-      { "functionPointerCheck", constructFunctionPointerCheck( commandIt->first, commandIt->second.referencedIn ) },
-      { "leave", leave },
-      { "returnType", returnType },
-      { "vectorSizeCheck", vectorSizeCheckString },
-      { "vkCommand", commandIt->first } } );
-
-  return std::make_pair( declaration, definition );
-}
-
-bool VulkanHppGenerator::constructRAIIHandleMemberFunctionValue(
-  std::string &                                      functionDeclarations,
-  std::string &                                      functionDefinitions,
-  std::map<std::string, CommandData>::const_iterator commandIt,
-  size_t                                             initialSkipCount ) const
-{
-  // as the return type is not "VkResult", there are no success or error codes allowed
-  assert( commandIt->second.successCodes.empty() && commandIt->second.errorCodes.empty() );
-
-  bool                commandConstructed = false;
-  std::string         declaration, definition;
-  std::vector<size_t> returnParamIndices = determineNonConstPointerParamIndices( commandIt->second.params );
-  if ( returnParamIndices.empty() )
-  {
-    std::tie( commandConstructed, declaration, definition ) =
-      constructRAIIHandleMemberFunctionValue0Return( commandIt, initialSkipCount );
-  }
-
-  functionDeclarations += declaration;
-  functionDefinitions += definition;
-  return commandConstructed;
-}
-
-std::tuple<bool, std::string, std::string> VulkanHppGenerator::constructRAIIHandleMemberFunctionValue0Return(
-  std::map<std::string, CommandData>::const_iterator commandIt, size_t initialSkipCount ) const
-{
-  std::string              declaration, definition;
-  std::map<size_t, size_t> vectorParamIndices = determineVectorParamIndicesNew( commandIt->second.params );
-  if ( beginsWith( commandIt->second.returnType, "Vk" ) )
-  {
-    std::tie( declaration, definition ) =
-      constructRAIIHandleMemberFunctionVkType( commandIt, initialSkipCount, vectorParamIndices );
+    return replaceWithMap(
+      definitionTemplate,
+      { { "argumentList", argumentList },
+        { "callArguments", callArguments },
+        { "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) },
+        { "commandName", commandName },
+        { "functionPointerCheck", constructFunctionPointerCheck( commandIt->first, commandIt->second.referencedIn ) },
+        { "returnType", returnType },
+        { "vectorSizeCheck", vectorSizeCheckString },
+        { "vkCommand", commandIt->first } } );
   }
   else
   {
-    std::tie( declaration, definition ) =
-      constructRAIIHandleMemberFunctionType( commandIt, initialSkipCount, vectorParamIndices );
+    std::string const declarationTemplate =
+      R"(
+  VULKAN_HPP_NODISCARD ${returnType} ${commandName}( ${argumentList} ) const VULKAN_HPP_NOEXCEPT;
+)";
+
+    return replaceWithMap( declarationTemplate,
+                           {
+                             { "argumentList", argumentList },
+                             { "commandName", commandName },
+                             { "returnType", returnType },
+                           } );
   }
-  return std::make_tuple( true, declaration, definition );
 }
 
-bool VulkanHppGenerator::constructRAIIHandleMemberFunctionVoid(
-  std::string &                                      functionDeclarations,
-  std::string &                                      functionDefinitions,
+std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionVkType(
   std::map<std::string, CommandData>::const_iterator commandIt,
-  size_t                                             initialSkipCount ) const
+  size_t                                             initialSkipCount,
+  std::map<size_t, size_t> const &                   vectorParamIndices,
+  bool                                               definition ) const
+{
+  std::set<size_t> skippedParameters =
+    determineSkippedParams( commandIt->second.params, initialSkipCount, vectorParamIndices, {}, false );
+  std::string argumentList =
+    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, definition, false, false, false );
+  std::string commandName =
+    determineCommandName( commandIt->first, commandIt->second.params[initialSkipCount - 1].type.type, m_tags );
+  std::string returnType = namespacedType( commandIt->second.returnType );
+
+  if ( definition )
+  {
+    std::string const definitionTemplate =
+      R"(
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ${returnType} ${className}::${commandName}( ${argumentList} ) const VULKAN_HPP_NOEXCEPT
+  {${functionPointerCheck}${vectorSizeCheck}
+    return static_cast<${returnType}>( getDispatcher()->${vkCommand}( ${callArguments} ) );
+  }
+)";
+
+    std::string callArguments =
+      constructCallArgumentsEnhanced( commandIt->second.params, initialSkipCount, false, {}, {}, true );
+    std::pair<bool, std::map<size_t, std::vector<size_t>>> vectorSizeCheck = needsVectorSizeCheck( vectorParamIndices );
+    std::string                                            vectorSizeCheckString =
+      vectorSizeCheck.first
+                                                   ? constructRAIIHandleVectorSizeCheck(
+            commandIt->first, commandIt->second, initialSkipCount, vectorSizeCheck.second, skippedParameters )
+                                                   : "";
+
+    return replaceWithMap(
+      definitionTemplate,
+      { { "argumentList", argumentList },
+        { "callArguments", callArguments },
+        { "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) },
+        { "commandName", commandName },
+        { "functionPointerCheck", constructFunctionPointerCheck( commandIt->first, commandIt->second.referencedIn ) },
+        { "returnType", returnType },
+        { "vectorSizeCheck", vectorSizeCheckString },
+        { "vkCommand", commandIt->first } } );
+  }
+  else
+  {
+    std::string const declarationTemplate =
+      R"(
+  VULKAN_HPP_NODISCARD ${returnType} ${commandName}( ${argumentList} ) const VULKAN_HPP_NOEXCEPT;
+)";
+
+    return replaceWithMap( declarationTemplate,
+                           {
+                             { "argumentList", argumentList },
+                             { "commandName", commandName },
+                             { "returnType", returnType },
+                           } );
+  }
+}
+
+std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionValue(
+  std::map<std::string, CommandData>::const_iterator commandIt, size_t initialSkipCount, bool definition ) const
 {
   // as the return type is not "VkResult", there are no success or error codes allowed
   assert( commandIt->second.successCodes.empty() && commandIt->second.errorCodes.empty() );
 
-  bool                commandConstructed = false;
-  std::string         declaration, definition;
+  std::string         function;
+  std::vector<size_t> returnParamIndices = determineNonConstPointerParamIndices( commandIt->second.params );
+  if ( returnParamIndices.empty() )
+  {
+    function = constructRAIIHandleMemberFunctionValue0Return( commandIt, initialSkipCount, definition );
+  }
+  return function;
+}
+
+std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionValue0Return(
+  std::map<std::string, CommandData>::const_iterator commandIt, size_t initialSkipCount, bool definition ) const
+{
+  std::string              function;
+  std::map<size_t, size_t> vectorParamIndices = determineVectorParamIndicesNew( commandIt->second.params );
+  if ( beginsWith( commandIt->second.returnType, "Vk" ) )
+  {
+    function = constructRAIIHandleMemberFunctionVkType( commandIt, initialSkipCount, vectorParamIndices, definition );
+  }
+  else
+  {
+    function = constructRAIIHandleMemberFunctionType( commandIt, initialSkipCount, vectorParamIndices, definition );
+  }
+  return function;
+}
+
+std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionVoid(
+  std::map<std::string, CommandData>::const_iterator commandIt, size_t initialSkipCount, bool definition ) const
+{
+  // as the return type is not "VkResult", there are no success or error codes allowed
+  assert( commandIt->second.successCodes.empty() && commandIt->second.errorCodes.empty() );
+
+  std::string         function;
   std::vector<size_t> returnParamIndices = determineNonConstPointerParamIndices( commandIt->second.params );
   switch ( returnParamIndices.size() )
   {
-    case 0:
-      std::tie( commandConstructed, declaration, definition ) =
-        constructRAIIHandleMemberFunctionVoid0Return( commandIt, initialSkipCount );
-      break;
+    case 0: function = constructRAIIHandleMemberFunctionVoid0Return( commandIt, initialSkipCount, definition ); break;
     case 1:
-      std::tie( commandConstructed, declaration, definition ) =
-        constructRAIIHandleMemberFunctionVoid1Return( commandIt, initialSkipCount, returnParamIndices[0] );
+      function =
+        constructRAIIHandleMemberFunctionVoid1Return( commandIt, initialSkipCount, returnParamIndices[0], definition );
       break;
     case 2:
-      std::tie( commandConstructed, declaration, definition ) =
-        constructRAIIHandleMemberFunctionVoid2Return( commandIt, initialSkipCount, returnParamIndices );
+      function =
+        constructRAIIHandleMemberFunctionVoid2Return( commandIt, initialSkipCount, returnParamIndices, definition );
       break;
   }
-
-  functionDeclarations += declaration;
-  functionDefinitions += definition;
-  return commandConstructed;
+  return function;
 }
 
-std::tuple<bool, std::string, std::string> VulkanHppGenerator::constructRAIIHandleMemberFunctionVoid0Return(
-  std::map<std::string, CommandData>::const_iterator commandIt, size_t initialSkipCount ) const
+std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionVoid0Return(
+  std::map<std::string, CommandData>::const_iterator commandIt, size_t initialSkipCount, bool definition ) const
 {
   std::map<size_t, size_t> vectorParamIndices = determineVectorParamIndicesNew( commandIt->second.params );
-
-  std::set<size_t> skippedParameters =
+  std::set<size_t>         skippedParameters =
     determineSkippedParams( commandIt->second.params, initialSkipCount, vectorParamIndices, {}, false );
-  std::string argumentListDeclaration =
-    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, false, false, false, false );
-  std::string argumentListDefinition =
-    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, true, false, false, false );
-  std::string callArguments =
-    constructCallArgumentsEnhanced( commandIt->second.params, initialSkipCount, false, {}, {}, true );
+  std::string argumentList =
+    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, definition, false, false, false );
   std::string commandName =
     determineCommandName( commandIt->first, commandIt->second.params[initialSkipCount - 1].type.type, m_tags );
-  std::string enter, leave;
-  std::tie( enter, leave ) = generateProtection( commandIt->second.referencedIn );
   std::pair<bool, std::map<size_t, std::vector<size_t>>> vectorSizeCheck = needsVectorSizeCheck( vectorParamIndices );
   std::string noexceptString = vectorSizeCheck.first ? "VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS" : "VULKAN_HPP_NOEXCEPT";
-  std::string vectorSizeCheckString =
-    vectorSizeCheck.first
-      ? constructVectorSizeCheck(
-          commandIt->first, commandIt->second, initialSkipCount, vectorSizeCheck.second, skippedParameters )
-      : "";
-
   std::string templateString = ( ( vectorParamIndices.size() == 1 ) &&
                                  ( commandIt->second.params[vectorParamIndices.begin()->first].type.type == "void" ) )
                                  ? "template <typename T>\n"
                                  : "";
 
-  std::string const declarationTemplate =
-    R"(
-${enter}    ${template}void ${commandName}( ${argumentList} ) const ${noexcept};
-${leave})";
-
-  std::string declaration = replaceWithMap( declarationTemplate,
-                                            { { "argumentList", argumentListDeclaration },
-                                              { "commandName", commandName },
-                                              { "enter", enter },
-                                              { "leave", leave },
-                                              { "noexcept", noexceptString },
-                                              { "template", templateString } } );
-
-  std::string const definitionTemplate =
-    R"(
-${enter}  ${template}VULKAN_HPP_INLINE void ${className}::${commandName}( ${argumentList} ) const ${noexcept}
+  if ( definition )
+  {
+    std::string const definitionTemplate =
+      R"(
+  ${template}VULKAN_HPP_INLINE void ${className}::${commandName}( ${argumentList} ) const ${noexcept}
   {${functionPointerCheck}${vectorSizeCheck}
     getDispatcher()->${vkCommand}( ${callArguments} );
   }
-${leave})";
+)";
 
-  std::string definition = replaceWithMap(
-    definitionTemplate,
-    { { "argumentList", argumentListDefinition },
-      { "callArguments", callArguments },
-      { "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) },
-      { "commandName", commandName },
-      { "enter", enter },
-      { "functionPointerCheck", constructFunctionPointerCheck( commandIt->first, commandIt->second.referencedIn ) },
-      { "leave", leave },
-      { "noexcept", noexceptString },
-      { "template", templateString },
-      { "vectorSizeCheck", vectorSizeCheckString },
-      { "vkCommand", commandIt->first } } );
+    std::string callArguments =
+      constructCallArgumentsEnhanced( commandIt->second.params, initialSkipCount, false, {}, {}, true );
+    std::string vectorSizeCheckString =
+      vectorSizeCheck.first
+        ? constructVectorSizeCheck(
+            commandIt->first, commandIt->second, initialSkipCount, vectorSizeCheck.second, skippedParameters )
+        : "";
 
-  return std::make_tuple( true, declaration, definition );
+    return replaceWithMap(
+      definitionTemplate,
+      { { "argumentList", argumentList },
+        { "callArguments", callArguments },
+        { "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) },
+        { "commandName", commandName },
+        { "functionPointerCheck", constructFunctionPointerCheck( commandIt->first, commandIt->second.referencedIn ) },
+        { "noexcept", noexceptString },
+        { "template", templateString },
+        { "vectorSizeCheck", vectorSizeCheckString },
+        { "vkCommand", commandIt->first } } );
+  }
+  else
+  {
+    std::string const declarationTemplate =
+      R"(
+    ${template}void ${commandName}( ${argumentList} ) const ${noexcept};
+)";
+
+    return replaceWithMap( declarationTemplate,
+                           { { "argumentList", argumentList },
+                             { "commandName", commandName },
+                             { "noexcept", noexceptString },
+                             { "template", templateString } } );
+  }
 }
 
-std::tuple<bool, std::string, std::string> VulkanHppGenerator::constructRAIIHandleMemberFunctionVoid1Return(
-  std::map<std::string, CommandData>::const_iterator commandIt, size_t initialSkipCount, size_t returnParamIndex ) const
+std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionVoid1Return(
+  std::map<std::string, CommandData>::const_iterator commandIt,
+  size_t                                             initialSkipCount,
+  size_t                                             returnParamIndex,
+  bool                                               definition ) const
 {
   // one return parameter (and it's not a handle, that would be a constructor)
   assert( !isHandleType( commandIt->second.params[returnParamIndex].type.type ) );
 
-  bool                     commandConstructed = false;
-  std::string              declaration, definition;
+  std::string              function;
   std::map<size_t, size_t> vectorParamIndices  = determineVectorParamIndicesNew( commandIt->second.params );
   auto                     returnVectorParamIt = vectorParamIndices.find( returnParamIndex );
   if ( returnVectorParamIt == vectorParamIndices.end() )
@@ -9593,40 +9675,39 @@ std::tuple<bool, std::string, std::string> VulkanHppGenerator::constructRAIIHand
     // the return parameter is not a vector -> return a value
     // as the return type is not "VkResult", there are no success or error codes allowed
     assert( commandIt->second.successCodes.empty() && commandIt->second.errorCodes.empty() );
-    std::tie( declaration, definition ) = constructRAIIHandleMemberFunctionVoidGetValue(
-      commandIt, initialSkipCount, vectorParamIndices, { returnParamIndex } );
-    commandConstructed = true;
+    function = constructRAIIHandleMemberFunctionVoidGetValue(
+      commandIt, initialSkipCount, vectorParamIndices, { returnParamIndex }, definition );
   }
   if ( isStructureChainAnchor( commandIt->second.params[returnParamIndex].type.type ) )
   {
     // for StructureChain returns, add functions returning a StructureChain
-    commandConstructed = false;
     if ( returnVectorParamIt == vectorParamIndices.end() )
     {
       // as the return type is not "VkResult", there are no success or error codes allowed
       assert( commandIt->second.successCodes.empty() && commandIt->second.errorCodes.empty() );
       std::string chainDeclaration, chainDefinition;
-      std::tie( chainDeclaration, chainDefinition ) = constructRAIIHandleMemberFunctionVoidGetChain(
-        commandIt, initialSkipCount, vectorParamIndices, { returnParamIndex } );
-      declaration += chainDeclaration;
-      definition += chainDefinition;
-      commandConstructed = true;
+      function += constructRAIIHandleMemberFunctionVoidGetChain(
+        commandIt, initialSkipCount, vectorParamIndices, { returnParamIndex }, definition );
+    }
+    else
+    {
+      throw std::runtime_error( "Never encountered a function like <" + commandIt->first + "> !" );
     }
   }
-  return std::make_tuple( commandConstructed, declaration, definition );
+  return function;
 }
 
-std::tuple<bool, std::string, std::string> VulkanHppGenerator::constructRAIIHandleMemberFunctionVoid2Return(
+std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionVoid2Return(
   std::map<std::string, CommandData>::const_iterator commandIt,
   size_t                                             initialSkipCount,
-  std::vector<size_t> const &                        returnParamIndices ) const
+  std::vector<size_t> const &                        returnParamIndices,
+  bool                                               definition ) const
 {
   // two return parameters (and the first one is not a handle, that would be a constructor)
   assert( returnParamIndices.size() == 2 );
   assert( !isHandleType( commandIt->second.params[returnParamIndices[0]].type.type ) );
 
-  bool                     commandConstructed = false;
-  std::string              declaration, definition;
+  std::string              function;
   std::map<size_t, size_t> vectorParamIndices = determineVectorParamIndicesNew( commandIt->second.params );
   switch ( vectorParamIndices.size() )
   {
@@ -9638,20 +9719,18 @@ std::tuple<bool, std::string, std::string> VulkanHppGenerator::constructRAIIHand
              ( vectorParamIndexIt->first == returnParamIndices[1] ) )
         {
           // the size is a return value as well -> enumerate the values
-          std::tie( declaration, definition ) = constructRAIIHandleMemberFunctionVoidEnumerate(
-            commandIt, initialSkipCount, vectorParamIndices, returnParamIndices );
-          commandConstructed = true;
+          function = constructRAIIHandleMemberFunctionVoidEnumerate(
+            commandIt, initialSkipCount, vectorParamIndices, returnParamIndices, definition );
         }
       }
       break;
   }
   if ( isStructureChainAnchor( commandIt->second.params[returnParamIndices[0]].type.type ) )
   {
-    commandConstructed = false;
+    throw std::runtime_error( "Never encountered a function like <" + commandIt->first + "> !" );
   }
   if ( isStructureChainAnchor( commandIt->second.params[returnParamIndices[1]].type.type ) )
   {
-    commandConstructed = false;
     if ( vectorParamIndices.size() == 1 )
     {
       // two returns but just one vector
@@ -9663,64 +9742,43 @@ std::tuple<bool, std::string, std::string> VulkanHppGenerator::constructRAIIHand
         std::string vectorElementType = commandIt->second.params[vectorParamIndices.begin()->first].type.type;
         if ( commandIt->second.returnType == "void" )
         {
-          std::string chainDeclaration, chainDefinition;
-          std::tie( chainDeclaration, chainDefinition ) = constructRAIIHandleMemberFunctionVoidEnumerateChain(
-            commandIt, initialSkipCount, vectorParamIndices, returnParamIndices );
-          declaration += chainDeclaration;
-          definition += chainDefinition;
-          commandConstructed = true;
+          function += constructRAIIHandleMemberFunctionVoidEnumerateChain(
+            commandIt, initialSkipCount, vectorParamIndices, returnParamIndices, definition );
         }
       }
+      else
+      {
+        throw std::runtime_error( "Never encountered a function like <" + commandIt->first + "> !" );
+      }
     }
   }
-  return std::make_tuple( commandConstructed, declaration, definition );
+  return function;
 }
 
-std::pair<std::string, std::string> VulkanHppGenerator::constructRAIIHandleMemberFunctionVoidEnumerate(
+std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionVoidEnumerate(
   std::map<std::string, CommandData>::const_iterator commandIt,
   size_t                                             initialSkipCount,
   std::map<size_t, size_t> const &                   vectorParamIndices,
-  std::vector<size_t> const &                        nonConstPointerParamIndices ) const
+  std::vector<size_t> const &                        nonConstPointerParamIndices,
+  bool                                               definition ) const
 {
   assert( nonConstPointerParamIndices.size() == 2 );
   assert( vectorParamIndices.size() == 1 );
 
   std::set<size_t> skippedParameters = determineSkippedParams(
     commandIt->second.params, initialSkipCount, vectorParamIndices, nonConstPointerParamIndices, false );
-  std::string argumentListDeclaration =
-    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, false, false, false, false );
-  std::string argumentListDefinition =
-    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, true, false, false, false );
+  std::string argumentList =
+    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, definition, false, false, false );
   std::string commandName =
     determineCommandName( commandIt->first, commandIt->second.params[initialSkipCount - 1].type.type, m_tags );
-  std::string enter, leave;
-  std::tie( enter, leave ) = generateProtection( commandIt->second.referencedIn );
   std::string vectorElementType =
     stripPostfix( commandIt->second.params[vectorParamIndices.begin()->first].type.compose(), "*" );
-  std::string counterName =
-    startLowerCase( stripPrefix( commandIt->second.params[vectorParamIndices.begin()->second].name, "p" ) );
-  std::string vectorName =
-    startLowerCase( stripPrefix( commandIt->second.params[vectorParamIndices.begin()->first].name, "p" ) );
-  std::string firstCallArguments = constructCallArgumentsEnhanced(
-    commandIt->second.params, initialSkipCount, true, {}, nonConstPointerParamIndices, true );
-  std::string secondCallArguments = constructCallArgumentsEnhanced(
-    commandIt->second.params, initialSkipCount, false, {}, nonConstPointerParamIndices, true );
 
-  std::string const declarationTemplate =
-    R"(
-${enter}    VULKAN_HPP_NODISCARD std::vector<${vectorElementType}> ${commandName}( ${argumentList} ) const VULKAN_HPP_NOEXCEPT;
-${leave})";
-
-  std::string declaration = replaceWithMap( declarationTemplate,
-                                            { { "argumentList", argumentListDeclaration },
-                                              { "commandName", commandName },
-                                              { "enter", enter },
-                                              { "leave", leave },
-                                              { "vectorElementType", vectorElementType } } );
-
-  const std::string definitionTemplate =
-    R"(
-${enter}  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<${vectorElementType}> ${className}::${commandName}( ${argumentList} ) const VULKAN_HPP_NOEXCEPT
+  if ( definition )
+  {
+    const std::string definitionTemplate =
+      R"(
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<${vectorElementType}> ${className}::${commandName}( ${argumentList} ) const VULKAN_HPP_NOEXCEPT
   {${functionPointerCheck}
     ${counterType} ${counterName};
     getDispatcher()->${vkCommand}( ${firstCallArguments} );
@@ -9729,68 +9787,66 @@ ${enter}  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<${vectorElementType
     VULKAN_HPP_ASSERT( ${counterName} <= ${vectorName}.size() );
     return ${vectorName};
   }
-${leave})";
+)";
 
-  std::string definition = replaceWithMap(
-    definitionTemplate,
-    { { "argumentList", argumentListDefinition },
-      { "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) },
-      { "commandName", commandName },
-      { "counterName", counterName },
-      { "counterType", commandIt->second.params[vectorParamIndices.begin()->second].type.type },
-      { "enter", enter },
-      { "firstCallArguments", firstCallArguments },
-      { "functionPointerCheck", constructFunctionPointerCheck( commandIt->first, commandIt->second.referencedIn ) },
-      { "leave", leave },
-      { "secondCallArguments", secondCallArguments },
-      { "vectorElementType", vectorElementType },
-      { "vectorName", vectorName },
-      { "vkCommand", commandIt->first } } );
-  return std::make_pair( declaration, definition );
+    std::string counterName =
+      startLowerCase( stripPrefix( commandIt->second.params[vectorParamIndices.begin()->second].name, "p" ) );
+    std::string firstCallArguments = constructCallArgumentsEnhanced(
+      commandIt->second.params, initialSkipCount, true, {}, nonConstPointerParamIndices, true );
+    std::string secondCallArguments = constructCallArgumentsEnhanced(
+      commandIt->second.params, initialSkipCount, false, {}, nonConstPointerParamIndices, true );
+    std::string vectorName =
+      startLowerCase( stripPrefix( commandIt->second.params[vectorParamIndices.begin()->first].name, "p" ) );
+
+    return replaceWithMap(
+      definitionTemplate,
+      { { "argumentList", argumentList },
+        { "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) },
+        { "commandName", commandName },
+        { "counterName", counterName },
+        { "counterType", commandIt->second.params[vectorParamIndices.begin()->second].type.type },
+        { "firstCallArguments", firstCallArguments },
+        { "functionPointerCheck", constructFunctionPointerCheck( commandIt->first, commandIt->second.referencedIn ) },
+        { "secondCallArguments", secondCallArguments },
+        { "vectorElementType", vectorElementType },
+        { "vectorName", vectorName },
+        { "vkCommand", commandIt->first } } );
+  }
+  else
+  {
+    std::string const declarationTemplate =
+      R"(
+    VULKAN_HPP_NODISCARD std::vector<${vectorElementType}> ${commandName}( ${argumentList} ) const VULKAN_HPP_NOEXCEPT;
+)";
+
+    return replaceWithMap( declarationTemplate,
+                           { { "argumentList", argumentList },
+                             { "commandName", commandName },
+                             { "vectorElementType", vectorElementType } } );
+  }
 }
 
-std::pair<std::string, std::string> VulkanHppGenerator::constructRAIIHandleMemberFunctionVoidEnumerateChain(
+std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionVoidEnumerateChain(
   std::map<std::string, CommandData>::const_iterator commandIt,
   size_t                                             initialSkipCount,
   std::map<size_t, size_t> const &                   vectorParamIndices,
-  std::vector<size_t> const &                        nonConstPointerParamIndices ) const
+  std::vector<size_t> const &                        nonConstPointerParamIndices,
+  bool                                               definition ) const
 {
   std::set<size_t> skippedParameters = determineSkippedParams(
     commandIt->second.params, initialSkipCount, vectorParamIndices, nonConstPointerParamIndices, false );
-  std::string argumentListDeclaration =
-    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, false, false, false, false );
-  std::string argumentListDefinition =
-    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, true, false, false, false );
+  std::string argumentList =
+    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, definition, false, false, false );
   std::string counterName =
     startLowerCase( stripPrefix( commandIt->second.params[vectorParamIndices.begin()->second].name, "p" ) );
   std::string commandName =
     determineCommandName( commandIt->first, commandIt->second.params[initialSkipCount - 1].type.type, m_tags );
-  std::string enter, leave;
-  std::tie( enter, leave )       = generateProtection( commandIt->second.referencedIn );
-  std::string firstCallArguments = constructCallArgumentsEnhanced(
-    commandIt->second.params, initialSkipCount, true, {}, nonConstPointerParamIndices, true );
-  std::string secondCallArguments = constructCallArgumentsEnhanced(
-    commandIt->second.params, initialSkipCount, false, {}, nonConstPointerParamIndices, true );
-  std::string vectorElementType =
-    stripPostfix( commandIt->second.params[vectorParamIndices.begin()->first].type.compose(), "*" );
-  std::string vectorName =
-    startLowerCase( stripPrefix( commandIt->second.params[vectorParamIndices.begin()->first].name, "p" ) );
 
-  std::string const declarationTemplate =
-    R"(
-${enter}    template <typename StructureChain>
-    VULKAN_HPP_NODISCARD std::vector<StructureChain> ${commandName}( ${argumentList} ) const;
-${leave})";
-
-  std::string declaration = replaceWithMap( declarationTemplate,
-                                            { { "argumentList", argumentListDeclaration },
-                                              { "commandName", commandName },
-                                              { "enter", enter },
-                                              { "leave", leave } } );
-
-  const std::string definitionTemplate =
-    R"(
-${enter}  template <typename StructureChain>
+  if ( definition )
+  {
+    const std::string definitionTemplate =
+      R"(
+  template <typename StructureChain>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<StructureChain> ${className}::${commandName}( ${argumentList} ) const
   {${functionPointerCheck}
     ${counterType} ${counterName};
@@ -9809,64 +9865,66 @@ ${enter}  template <typename StructureChain>
     }
     return returnVector;
   }
-${leave})";
+)";
 
-  std::string definition = replaceWithMap(
-    definitionTemplate,
-    { { "argumentList", argumentListDefinition },
-      { "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) },
-      { "commandName", commandName },
-      { "counterName", counterName },
-      { "counterType", commandIt->second.params[vectorParamIndices.begin()->second].type.type },
-      { "enter", enter },
-      { "firstCallArguments", firstCallArguments },
-      { "functionPointerCheck", constructFunctionPointerCheck( commandIt->first, commandIt->second.referencedIn ) },
-      { "leave", leave },
-      { "secondCallArguments", secondCallArguments },
-      { "vectorElementType", vectorElementType },
-      { "vectorName", vectorName },
-      { "vkCommand", commandIt->first } } );
+    std::string firstCallArguments = constructCallArgumentsEnhanced(
+      commandIt->second.params, initialSkipCount, true, {}, nonConstPointerParamIndices, true );
+    std::string secondCallArguments = constructCallArgumentsEnhanced(
+      commandIt->second.params, initialSkipCount, false, {}, nonConstPointerParamIndices, true );
+    std::string vectorElementType =
+      stripPostfix( commandIt->second.params[vectorParamIndices.begin()->first].type.compose(), "*" );
+    std::string vectorName =
+      startLowerCase( stripPrefix( commandIt->second.params[vectorParamIndices.begin()->first].name, "p" ) );
 
-  return std::make_pair( declaration, definition );
+    return replaceWithMap(
+      definitionTemplate,
+      { { "argumentList", argumentList },
+        { "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) },
+        { "commandName", commandName },
+        { "counterName", counterName },
+        { "counterType", commandIt->second.params[vectorParamIndices.begin()->second].type.type },
+        { "firstCallArguments", firstCallArguments },
+        { "functionPointerCheck", constructFunctionPointerCheck( commandIt->first, commandIt->second.referencedIn ) },
+        { "secondCallArguments", secondCallArguments },
+        { "vectorElementType", vectorElementType },
+        { "vectorName", vectorName },
+        { "vkCommand", commandIt->first } } );
+  }
+  else
+  {
+    std::string const declarationTemplate =
+      R"(
+    template <typename StructureChain>
+    VULKAN_HPP_NODISCARD std::vector<StructureChain> ${commandName}( ${argumentList} ) const;
+)";
+
+    return replaceWithMap( declarationTemplate,
+                           {
+                             { "argumentList", argumentList },
+                             { "commandName", commandName },
+                           } );
+  }
 }
 
-std::pair<std::string, std::string> VulkanHppGenerator::constructRAIIHandleMemberFunctionVoidGetChain(
+std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionVoidGetChain(
   std::map<std::string, CommandData>::const_iterator commandIt,
   size_t                                             initialSkipCount,
   std::map<size_t, size_t> const &                   vectorParamIndices,
-  std::vector<size_t> const &                        nonConstPointerParamIndices ) const
+  std::vector<size_t> const &                        nonConstPointerParamIndices,
+  bool                                               definition ) const
 {
   std::set<size_t> skippedParameters = determineSkippedParams(
     commandIt->second.params, initialSkipCount, vectorParamIndices, nonConstPointerParamIndices, false );
-  std::string argumentListDeclaration =
-    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, false, false, false, false );
-  std::string argumentListDefinition =
-    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, true, false, false, false );
-  std::string callArguments = constructCallArgumentsEnhanced(
-    commandIt->second.params, initialSkipCount, false, {}, nonConstPointerParamIndices, true );
+  std::string argumentList =
+    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, definition, false, false, false );
   std::string commandName =
     determineCommandName( commandIt->first, commandIt->second.params[initialSkipCount - 1].type.type, m_tags );
-  std::string enter, leave;
-  std::tie( enter, leave ) = generateProtection( commandIt->second.referencedIn );
-  std::string returnType = stripPostfix( commandIt->second.params[nonConstPointerParamIndices[0]].type.compose(), "*" );
-  std::string returnVariable =
-    startLowerCase( stripPrefix( commandIt->second.params[nonConstPointerParamIndices[0]].name, "p" ) );
 
-  std::string const declarationTemplate =
-    R"(
-${enter}  template <typename X, typename Y, typename... Z>
-    VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> ${commandName}( ${argumentList} ) const VULKAN_HPP_NOEXCEPT;
-${leave})";
-
-  std::string declaration = replaceWithMap( declarationTemplate,
-                                            { { "argumentList", argumentListDeclaration },
-                                              { "commandName", commandName },
-                                              { "enter", enter },
-                                              { "leave", leave } } );
-
-  std::string const definitionTemplate =
-    R"(
-${enter}  template <typename X, typename Y, typename... Z>
+  if ( definition )
+  {
+    std::string const definitionTemplate =
+      R"(
+  template <typename X, typename Y, typename... Z>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> ${className}::${commandName}( ${argumentList} ) const VULKAN_HPP_NOEXCEPT
   {${functionPointerCheck}
     StructureChain<X, Y, Z...> structureChain;
@@ -9874,94 +9932,108 @@ ${enter}  template <typename X, typename Y, typename... Z>
     getDispatcher()->${vkCommand}( ${callArguments} );
     return structureChain;
   }
-${leave})";
+)";
 
-  std::string definition = replaceWithMap(
-    definitionTemplate,
-    { { "argumentList", argumentListDefinition },
-      { "callArguments", callArguments },
-      { "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) },
-      { "commandName", commandName },
-      { "enter", enter },
-      { "functionPointerCheck", constructFunctionPointerCheck( commandIt->first, commandIt->second.referencedIn ) },
-      { "leave", leave },
-      { "returnVariable", returnVariable },
-      { "returnType", returnType },
-      { "vkCommand", commandIt->first } } );
+    std::string callArguments = constructCallArgumentsEnhanced(
+      commandIt->second.params, initialSkipCount, false, {}, nonConstPointerParamIndices, true );
+    std::string returnType =
+      stripPostfix( commandIt->second.params[nonConstPointerParamIndices[0]].type.compose(), "*" );
+    std::string returnVariable =
+      startLowerCase( stripPrefix( commandIt->second.params[nonConstPointerParamIndices[0]].name, "p" ) );
 
-  return std::make_pair( declaration, definition );
+    return replaceWithMap(
+      definitionTemplate,
+      { { "argumentList", argumentList },
+        { "callArguments", callArguments },
+        { "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) },
+        { "commandName", commandName },
+        { "functionPointerCheck", constructFunctionPointerCheck( commandIt->first, commandIt->second.referencedIn ) },
+        { "returnVariable", returnVariable },
+        { "returnType", returnType },
+        { "vkCommand", commandIt->first } } );
+  }
+  else
+  {
+    std::string const declarationTemplate =
+      R"(
+  template <typename X, typename Y, typename... Z>
+    VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> ${commandName}( ${argumentList} ) const VULKAN_HPP_NOEXCEPT;
+)";
+
+    return replaceWithMap( declarationTemplate,
+                           {
+                             { "argumentList", argumentList },
+                             { "commandName", commandName },
+                           } );
+  }
 }
 
-std::pair<std::string, std::string> VulkanHppGenerator::constructRAIIHandleMemberFunctionVoidGetValue(
+std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionVoidGetValue(
   std::map<std::string, CommandData>::const_iterator commandIt,
   size_t                                             initialSkipCount,
   std::map<size_t, size_t> const &                   vectorParamIndices,
-  std::vector<size_t> const &                        nonConstPointerParamIndices ) const
+  std::vector<size_t> const &                        nonConstPointerParamIndices,
+  bool                                               definition ) const
 {
   assert( nonConstPointerParamIndices.size() == 1 );
 
   std::set<size_t> skippedParameters = determineSkippedParams(
     commandIt->second.params, initialSkipCount, vectorParamIndices, nonConstPointerParamIndices, false );
-  std::string argumentListDeclaration =
-    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, false, false, false, false );
-  std::string argumentListDefinition =
-    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, true, false, false, false );
+  std::string argumentList =
+    constructArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, definition, false, false, false );
   std::string commandName =
     determineCommandName( commandIt->first, commandIt->second.params[initialSkipCount - 1].type.type, m_tags );
-  std::string enter, leave;
-  std::tie( enter, leave ) = generateProtection( commandIt->second.referencedIn );
   std::string returnType = stripPostfix( commandIt->second.params[nonConstPointerParamIndices[0]].type.compose(), "*" );
   std::pair<bool, std::map<size_t, std::vector<size_t>>> vectorSizeCheck = needsVectorSizeCheck( vectorParamIndices );
   std::string noexceptString = vectorSizeCheck.first ? "VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS" : "VULKAN_HPP_NOEXCEPT";
 
-  std::string const declarationTemplate =
-    R"(
-${enter}  VULKAN_HPP_NODISCARD ${returnType} ${commandName}( ${argumentList} ) const ${noexcept};
-${leave})";
-
-  std::string declaration = replaceWithMap( declarationTemplate,
-                                            {
-                                              { "argumentList", argumentListDeclaration },
-                                              { "commandName", commandName },
-                                              { "enter", enter },
-                                              { "leave", leave },
-                                              { "noexcept", noexceptString },
-                                              { "returnType", returnType },
-                                            } );
-
-  std::string const definitionTemplate =
-    R"(
-${enter}  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ${returnType} ${className}::${commandName}( ${argumentList} ) const ${noexcept}
+  if ( definition )
+  {
+    std::string const definitionTemplate =
+      R"(
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ${returnType} ${className}::${commandName}( ${argumentList} ) const ${noexcept}
   {${functionPointerCheck}${vectorSizeCheck}
     ${returnType} ${returnVariable};
     getDispatcher()->${vkCommand}( ${callArguments} );
     return ${returnVariable};
   }
-${leave})";
+)";
 
-  std::string definition = replaceWithMap(
-    definitionTemplate,
-    { { "argumentList", argumentListDefinition },
-      { "callArguments",
-        constructCallArgumentsEnhanced(
-          commandIt->second.params, initialSkipCount, false, {}, nonConstPointerParamIndices, true ) },
-      { "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) },
-      { "commandName", commandName },
-      { "enter", enter },
-      { "functionPointerCheck", constructFunctionPointerCheck( commandIt->first, commandIt->second.referencedIn ) },
-      { "leave", leave },
-      { "noexcept", noexceptString },
-      { "vectorSizeCheck",
-        vectorSizeCheck.first
-          ? constructVectorSizeCheck(
-              commandIt->first, commandIt->second, initialSkipCount, vectorSizeCheck.second, skippedParameters )
-          : "" },
-      { "returnType", returnType },
-      { "returnVariable",
-        startLowerCase( stripPrefix( commandIt->second.params[nonConstPointerParamIndices[0]].name, "p" ) ) },
-      { "vkCommand", commandIt->first } } );
+    return replaceWithMap(
+      definitionTemplate,
+      { { "argumentList", argumentList },
+        { "callArguments",
+          constructCallArgumentsEnhanced(
+            commandIt->second.params, initialSkipCount, false, {}, nonConstPointerParamIndices, true ) },
+        { "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) },
+        { "commandName", commandName },
+        { "functionPointerCheck", constructFunctionPointerCheck( commandIt->first, commandIt->second.referencedIn ) },
+        { "noexcept", noexceptString },
+        { "vectorSizeCheck",
+          vectorSizeCheck.first
+            ? constructVectorSizeCheck(
+                commandIt->first, commandIt->second, initialSkipCount, vectorSizeCheck.second, skippedParameters )
+            : "" },
+        { "returnType", returnType },
+        { "returnVariable",
+          startLowerCase( stripPrefix( commandIt->second.params[nonConstPointerParamIndices[0]].name, "p" ) ) },
+        { "vkCommand", commandIt->first } } );
+  }
+  else
+  {
+    std::string const declarationTemplate =
+      R"(
+  VULKAN_HPP_NODISCARD ${returnType} ${commandName}( ${argumentList} ) const ${noexcept};
+)";
 
-  return std::make_pair( declaration, definition );
+    return replaceWithMap( declarationTemplate,
+                           {
+                             { "argumentList", argumentList },
+                             { "commandName", commandName },
+                             { "noexcept", noexceptString },
+                             { "returnType", returnType },
+                           } );
+  }
 }
 
 std::string VulkanHppGenerator::constructRAIIHandleSingularConstructorArguments(
@@ -10510,6 +10582,7 @@ std::string VulkanHppGenerator::appendStructMembers( std::string &
 
 void VulkanHppGenerator::appendStructs( std::string & str )
 {
+  // Note reordering structs or handles by features and extensions is not possible!
   for ( auto const & structure : m_structures )
   {
     if ( m_listedTypes.find( structure.first ) == m_listedTypes.end() )
@@ -11475,6 +11548,25 @@ std::string VulkanHppGenerator::determineEnhancedReturnType( CommandData const &
                                 ",Allocator>";  // for the other parameters, we use a vector of the pure type
 }
 
+size_t VulkanHppGenerator::determineInitialSkipCount( std::string const & command ) const
+{
+  auto commandIt = m_commands.find( command );
+  assert( commandIt != m_commands.end() );
+  auto handleIt = m_handles.find( commandIt->second.handle );
+  assert( handleIt != m_handles.end() );
+  if ( handleIt->second.commands.find( command ) == handleIt->second.commands.end() )
+  {
+    assert( 1 < commandIt->second.params.size() );
+    handleIt = m_handles.find( commandIt->second.params[1].type.type );
+    assert( handleIt != m_handles.end() );
+    return 2;
+  }
+  else
+  {
+    return handleIt->first.empty() ? 0 : 1;
+  }
+}
+
 std::vector<std::map<std::string, VulkanHppGenerator::CommandData>::const_iterator>
   VulkanHppGenerator::determineRAIIHandleConstructors( std::string const &                                handleType,
                                                        std::map<std::string, CommandData>::const_iterator destructorIt,
@@ -11847,6 +11939,30 @@ void VulkanHppGenerator::distributeSecondLevelCommands( std::set<std::string> co
   }
 }
 
+std::set<std::string> VulkanHppGenerator::determineSpecialFunctions()
+{
+  // filter out functions that are not usefull on this level of abstraction (like vkGetInstanceProcAddr)
+  // and all the construction and destruction functions, as they are used differently
+  std::set<std::string> specialFunctions;
+  for ( auto & handle : m_handles )
+  {
+    if ( !handle.first.empty() )
+    {
+      handle.second.destructorIt = determineRAIIHandleDestructor( handle.first );
+      if ( handle.second.destructorIt != m_commands.end() )
+      {
+        specialFunctions.insert( handle.second.destructorIt->first );
+      }
+      handle.second.constructorIts =
+        determineRAIIHandleConstructors( handle.first, handle.second.destructorIt, specialFunctions );
+    }
+  }
+
+  distributeSecondLevelCommands( specialFunctions );
+  renameFunctionParameters();
+  return specialFunctions;
+}
+
 std::string const & VulkanHppGenerator::getTypesafeCheck() const
 {
   return m_typesafeCheck;
@@ -14608,7 +14724,6 @@ void VulkanHppGenerator::renameFunctionParameters()
 }
 
 void VulkanHppGenerator::rescheduleRAIIHandle( std::string &                              str,
-                                               std::string &                              commandDefinitions,
                                                std::pair<std::string, HandleData> const & handle,
                                                std::set<std::string> &                    listedHandles,
                                                std::set<std::string> const &              specialFunctions ) const
@@ -14618,7 +14733,7 @@ void VulkanHppGenerator::rescheduleRAIIHandle( std::string &
   {
     auto parentIt = m_handles.find( handle.second.parent );
     assert( parentIt != m_handles.end() );
-    appendRAIIHandle( str, commandDefinitions, *parentIt, listedHandles, specialFunctions );
+    appendRAIIHandle( str, *parentIt, listedHandles, specialFunctions );
   }
 
   for ( auto constructorIt : handle.second.constructorIts )
@@ -14628,7 +14743,7 @@ void VulkanHppGenerator::rescheduleRAIIHandle( std::string &
       auto handleIt = m_handles.find( param.type.type );
       if ( handleIt != m_handles.end() && ( listedHandles.find( param.type.type ) == listedHandles.end() ) )
       {
-        appendRAIIHandle( str, commandDefinitions, *handleIt, listedHandles, specialFunctions );
+        appendRAIIHandle( str, *handleIt, listedHandles, specialFunctions );
       }
     }
   }
@@ -16675,9 +16790,9 @@ namespace VULKAN_HPP_NAMESPACE
 
     generator.appendRAIIDispatchers( str );
 
-    std::string raiiHandlesCommandDefinitions;
-    generator.appendRAIIHandles( str, raiiHandlesCommandDefinitions );
-    str += raiiHandlesCommandDefinitions;
+    std::set<std::string> specialFunctions = generator.determineSpecialFunctions();
+    generator.appendRAIIHandles( str, specialFunctions );
+    generator.appendRAIICommands( str, specialFunctions );
     str += R"(
 #endif
   } // namespace VULKAN_HPP_RAII_NAMESPACE
diff --git a/VulkanHppGenerator.hpp b/VulkanHppGenerator.hpp
index d546f86..9a547b4 100644
--- a/VulkanHppGenerator.hpp
+++ b/VulkanHppGenerator.hpp
@@ -31,20 +31,22 @@ public:
   void appendDispatchLoaderStatic( std::string & str );   // use exported symbols from loader
   void appendDispatchLoaderDefault(
     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                appendHandlesCommandDefinitions( std::string & str ) const;
-  void                appendHashStructures( std::string & str ) const;
-  void                appendRAIIDispatchers( std::string & str ) const;
-  void                appendRAIIHandles( std::string & str, std::string & commandDefinitions );
-  void                appendResultExceptions( std::string & str ) const;
-  void                appendStructs( std::string & str );
-  void                appendStructureChainValidation( std::string & str );
-  void                appendThrowExceptions( std::string & str ) const;
-  void                appendIndexTypeTraits( std::string & str ) const;
-  std::string const & getTypesafeCheck() const;
-  std::string const & getVersion() const;
-  std::string const & getVulkanLicenseHeader() const;
+  void                  appendEnums( std::string & str ) const;
+  void                  appendHandles( std::string & str );
+  void                  appendHandlesCommandDefinitions( std::string & str ) const;
+  void                  appendHashStructures( std::string & str ) const;
+  void                  appendRAIICommands( std::string & str, std::set<std::string> const & specialFunctions ) const;
+  void                  appendRAIIDispatchers( std::string & str ) const;
+  void                  appendRAIIHandles( std::string & str, std::set<std::string> const & specialFunctions ) const;
+  void                  appendResultExceptions( std::string & str ) const;
+  void                  appendStructs( std::string & str );
+  void                  appendStructureChainValidation( std::string & str );
+  void                  appendThrowExceptions( std::string & str ) const;
+  void                  appendIndexTypeTraits( std::string & str ) const;
+  std::set<std::string> determineSpecialFunctions();
+  std::string const &   getTypesafeCheck() const;
+  std::string const &   getVersion() const;
+  std::string const &   getVulkanLicenseHeader() const;
 
 private:
   struct BaseTypeData
@@ -338,6 +340,7 @@ private:
                    std::map<size_t, size_t> const & vectorParamIndices,
                    bool                             twoStep,
                    bool                             firstCall ) const;
+  void appendCommand( std::string & str, std::string const & command, std::string const & handle ) const;
   void appendCommand( std::string &       str,
                       std::string const & name,
                       CommandData const & commandData,
@@ -490,6 +493,10 @@ private:
                                         size_t                      initialSkipCount,
                                         bool                        definition,
                                         std::vector<size_t> const & returnParamIndices ) const;
+  void        appendDestroyCommand( std::string &       str,
+                                    std::string const & name,
+                                    CommandData const & commandData,
+                                    std::string const & handleName ) const;
   void        appendDispatchLoaderDynamicCommand( std::string &       str,
                                                   std::string &       emptyFunctions,
                                                   std::string &       deviceFunctions,
@@ -546,12 +553,10 @@ private:
                                                           bool                isTemplateParam ) const;
   void        appendHandle( std::string & str, std::pair<std::string, HandleData> const & handle );
   void        appendRAIIHandle( std::string &                              str,
-                                std::string &                              commandDefinitions,
                                 std::pair<std::string, HandleData> const & handle,
                                 std::set<std::string> &                    listedHandles,
                                 std::set<std::string> const &              specialFunctions ) const;
   void        appendRAIIHandleContext( std::string &                              str,
-                                       std::string &                              commandDefinitions,
                                        std::pair<std::string, HandleData> const & handle,
                                        std::set<std::string> const &              specialFunctions ) const;
   std::pair<std::string, std::string> appendStaticCommand( std::string &                               str,
@@ -815,15 +820,16 @@ private:
     std::map<std::string, VulkanHppGenerator::CommandData>::const_iterator constructorIt,
     std::string const &                                                    enter,
     std::string const &                                                    leave ) const;
-  std::string                         constructRAIIHandleConstructorArguments( std::string const &            handleType,
-                                                                               std::vector<ParamData> const & params,
-                                                                               bool                           singular,
-                                                                               bool                           encounteredArgument ) const;
-  std::pair<std::string, std::string> constructRAIIHandleMemberFunctionResultSingleGetVector(
+  std::string constructRAIIHandleConstructorArguments( std::string const &            handleType,
+                                                       std::vector<ParamData> const & params,
+                                                       bool                           singular,
+                                                       bool                           encounteredArgument ) const;
+  std::string constructRAIIHandleMemberFunctionResultSingleGetVector(
     std::map<std::string, CommandData>::const_iterator commandIt,
     size_t                                             initialSkipCount,
     std::map<size_t, size_t> const &                   vectorParamIndices,
-    size_t                                             returnParamIndex ) const;
+    size_t                                             returnParamIndex,
+    bool                                               definition ) const;
   std::string constructRAIIHandleConstructorCallArguments( std::string const &            handleType,
                                                            std::vector<ParamData> const & params,
                                                            bool                           nonConstPointerAsNullptr,
@@ -874,166 +880,182 @@ private:
   std::string constructRAIIHandleDestructorCallArguments( std::string const &            handleType,
                                                           std::vector<ParamData> const & params ) const;
   std::tuple<std::string, std::string, std::string, std::string>
-    constructRAIIHandleDetails( std::pair<std::string, HandleData> const & handle,
-                                std::string const &                        destructorCall ) const;
-  std::pair<std::string, std::string>
+              constructRAIIHandleDetails( std::pair<std::string, HandleData> const & handle,
+                                          std::string const &                        destructorCall ) const;
+  std::string constructRAIIHandleMemberFunction( std::string const &           command,
+                                                 size_t                        initialSkipCount,
+                                                 std::set<std::string> const & specialFunctions,
+                                                 bool                          definition ) const;
+  std::string
     constructRAIIHandleMemberFunctionResultEnumerate( std::map<std::string, CommandData>::const_iterator commandIt,
                                                       size_t                           initialSkipCount,
                                                       std::map<size_t, size_t> const & vectorParamIndices,
-                                                      std::vector<size_t> const & nonConstPointerParamIndices ) const;
-  std::pair<std::string, std::string> constructRAIIHandleMemberFunctionResultEnumerateTwoVectors(
+                                                      std::vector<size_t> const &      nonConstPointerParamIndices,
+                                                      bool                             definition ) const;
+  std::string constructRAIIHandleMemberFunctionResultEnumerateTwoVectors(
     std::map<std::string, CommandData>::const_iterator commandIt,
     size_t                                             initialSkipCount,
     std::map<size_t, size_t> const &                   vectorParamIndices,
-    std::vector<size_t> const &                        nonConstPointerParamIndices ) const;
+    std::vector<size_t> const &                        nonConstPointerParamIndices,
+    bool                                               definition ) const;
   std::pair<std::string, std::string> constructRAIIHandleMemberFunctionResultGetTwoValues(
     std::map<std::string, CommandData>::const_iterator commandIt,
     size_t                                             initialSkipCount,
     std::map<size_t, size_t> const &                   vectorParamIndices,
     std::vector<size_t> const &                        nonConstPointerParamIndices ) const;
-  std::pair<std::string, std::string>
+  std::string
     constructRAIIHandleMemberFunctionResultMulti( std::map<std::string, CommandData>::const_iterator commandIt,
                                                   size_t                                             initialSkipCount,
-                                                  std::map<size_t, size_t> const & vectorParamIndices ) const;
-  std::pair<std::string, std::string> constructRAIIHandleMemberFunctionResultMultiGetValue(
+                                                  std::map<size_t, size_t> const &                   vectorParamIndices,
+                                                  bool                                               definition ) const;
+  std::string
+    constructRAIIHandleMemberFunctionResultMultiGetValue( std::map<std::string, CommandData>::const_iterator commandIt,
+                                                          size_t                           initialSkipCount,
+                                                          std::map<size_t, size_t> const & vectorParamIndices,
+                                                          std::vector<size_t> const &      nonConstPointerParamIndices,
+                                                          bool                             definition ) const;
+  std::string constructRAIIHandleMemberFunctionResultMultiGetVectorOfVoid(
     std::map<std::string, CommandData>::const_iterator commandIt,
     size_t                                             initialSkipCount,
     std::map<size_t, size_t> const &                   vectorParamIndices,
-    std::vector<size_t> const &                        nonConstPointerParamIndices ) const;
-  std::pair<std::string, std::string> constructRAIIHandleMemberFunctionResultMultiGetVectorOfVoid(
+    std::vector<size_t> const &                        nonConstPointerParamIndices,
+    bool                                               definition ) const;
+  std::string constructRAIIHandleMemberFunctionResultMultiGetVectorOfVoidSingular(
     std::map<std::string, CommandData>::const_iterator commandIt,
     size_t                                             initialSkipCount,
     std::map<size_t, size_t> const &                   vectorParamIndices,
-    std::vector<size_t> const &                        nonConstPointerParamIndices ) const;
-  std::pair<std::string, std::string> constructRAIIHandleMemberFunctionResultMultiGetVectorOfVoidSingular(
-    std::map<std::string, CommandData>::const_iterator commandIt,
-    size_t                                             initialSkipCount,
-    std::map<size_t, size_t> const &                   vectorParamIndices,
-    std::vector<size_t> const &                        nonConstPointerParamIndices ) const;
-  std::pair<std::string, std::string>
+    std::vector<size_t> const &                        nonConstPointerParamIndices,
+    bool                                               definition ) const;
+  std::string
     constructRAIIHandleMemberFunctionResultMultiNoErrors( std::map<std::string, CommandData>::const_iterator commandIt,
                                                           size_t                           initialSkipCount,
-                                                          std::map<size_t, size_t> const & vectorParamIndices ) const;
-  std::pair<std::string, std::string>
+                                                          std::map<size_t, size_t> const & vectorParamIndices,
+                                                          bool                             definition ) const;
+  std::string
     constructRAIIHandleMemberFunctionResultSingle( std::map<std::string, CommandData>::const_iterator commandIt,
                                                    size_t                                             initialSkipCount,
-                                                   std::map<size_t, size_t> const & vectorParamIndices ) const;
-  std::pair<std::string, std::string> constructRAIIHandleMemberFunctionResultSingleGetChain(
+                                                   std::map<size_t, size_t> const & vectorParamIndices,
+                                                   bool                             definition ) const;
+  std::string
+    constructRAIIHandleMemberFunctionResultSingleGetChain( std::map<std::string, CommandData>::const_iterator commandIt,
+                                                           size_t                           initialSkipCount,
+                                                           std::map<size_t, size_t> const & vectorParamIndices,
+                                                           std::vector<size_t> const &      nonConstPointerParamIndices,
+                                                           bool                             definition ) const;
+  std::string constructRAIIHandleMemberFunctionResultSingleGetVectorAndValue(
     std::map<std::string, CommandData>::const_iterator commandIt,
     size_t                                             initialSkipCount,
     std::map<size_t, size_t> const &                   vectorParamIndices,
-    std::vector<size_t> const &                        nonConstPointerParamIndices ) const;
-  std::pair<std::string, std::string> constructRAIIHandleMemberFunctionResultSingleGetVectorAndValue(
+    std::vector<size_t> const &                        nonConstPointerParamIndices,
+    bool                                               definition ) const;
+  std::string constructRAIIHandleMemberFunctionResultSingleGetVectorOfVoid(
     std::map<std::string, CommandData>::const_iterator commandIt,
     size_t                                             initialSkipCount,
     std::map<size_t, size_t> const &                   vectorParamIndices,
-    std::vector<size_t> const &                        nonConstPointerParamIndices ) const;
-  std::pair<std::string, std::string> constructRAIIHandleMemberFunctionResultSingleGetVectorOfVoid(
+    std::vector<size_t> const &                        nonConstPointerParamIndices,
+    bool                                               definition ) const;
+  std::string constructRAIIHandleMemberFunctionResultSingleGetVectorSingular(
     std::map<std::string, CommandData>::const_iterator commandIt,
     size_t                                             initialSkipCount,
     std::map<size_t, size_t> const &                   vectorParamIndices,
-    std::vector<size_t> const &                        nonConstPointerParamIndices ) const;
-  std::pair<std::string, std::string> constructRAIIHandleMemberFunctionResultSingleGetVectorSingular(
+    size_t                                             returnParamIndex,
+    bool                                               definition ) const;
+  std::string constructRAIIHandleMemberFunctionResultSingleGetVectorOfVoidSingular(
     std::map<std::string, CommandData>::const_iterator commandIt,
     size_t                                             initialSkipCount,
     std::map<size_t, size_t> const &                   vectorParamIndices,
-    size_t                                             returnParamIndex ) const;
-  std::pair<std::string, std::string> constructRAIIHandleMemberFunctionResultSingleGetVectorOfVoidSingular(
-    std::map<std::string, CommandData>::const_iterator commandIt,
-    size_t                                             initialSkipCount,
-    std::map<size_t, size_t> const &                   vectorParamIndices,
-    std::vector<size_t> const &                        nonConstPointerParamIndices ) const;
-  std::pair<std::string, std::string>
+    std::vector<size_t> const &                        nonConstPointerParamIndices,
+    bool                                               definition ) const;
+  std::string
     constructRAIIHandleMemberFunctionResultSingleNoErrors( std::map<std::string, CommandData>::const_iterator commandIt,
                                                            size_t                           initialSkipCount,
-                                                           std::map<size_t, size_t> const & vectorParamIndices ) const;
-  std::pair<std::string, std::string> constructRAIIHandleMemberFunctionResultSingleGetValue(
-    std::map<std::string, CommandData>::const_iterator commandIt,
-    size_t                                             initialSkipCount,
-    std::map<size_t, size_t> const &                   vectorParamIndices,
-    std::vector<size_t> const &                        nonConstPointerParamIndices ) const;
-  void constructRAIIHandleMemberFunction( std::string &                 functionDeclarations,
-                                          std::string &                 functionDefinitions,
-                                          std::string const &           command,
-                                          size_t                        initialSkipCount,
-                                          std::set<std::string> const & specialFunctions ) const;
+                                                           std::map<size_t, size_t> const & vectorParamIndices,
+                                                           bool                             definition ) const;
+  std::string
+    constructRAIIHandleMemberFunctionResultSingleGetValue( std::map<std::string, CommandData>::const_iterator commandIt,
+                                                           size_t                           initialSkipCount,
+                                                           std::map<size_t, size_t> const & vectorParamIndices,
+                                                           std::vector<size_t> const &      nonConstPointerParamIndices,
+                                                           bool                             definition ) const;
   std::pair<std::string, std::string>
-       constructRAIIHandleMemberFunctionBoolGetValue( std::map<std::string, CommandData>::const_iterator commandIt,
-                                                      size_t                                             initialSkipCount,
-                                                      std::map<size_t, size_t> const & vectorParamIndices,
-                                                      std::vector<size_t> const &      nonConstPointerParamIndices ) const;
-  bool constructRAIIHandleMemberFunctionResult( std::string &                                      functionDeclarations,
-                                                std::string &                                      functionDefinitions,
-                                                std::map<std::string, CommandData>::const_iterator commandIt,
-                                                size_t initialSkipCount ) const;
-  std::tuple<bool, std::string, std::string>
-    constructRAIIHandleMemberFunctionResult0Return( std::map<std::string, CommandData>::const_iterator commandIt,
-                                                    size_t initialSkipCount ) const;
-  std::tuple<bool, std::string, std::string>
+    constructRAIIHandleMemberFunctionBoolGetValue( std::map<std::string, CommandData>::const_iterator commandIt,
+                                                   size_t                                             initialSkipCount,
+                                                   std::map<size_t, size_t> const & vectorParamIndices,
+                                                   std::vector<size_t> const &      nonConstPointerParamIndices ) const;
+  std::string constructRAIIHandleMemberFunctionResult( std::map<std::string, CommandData>::const_iterator commandIt,
+                                                       size_t initialSkipCount,
+                                                       bool   definition ) const;
+  std::string constructRAIIHandleMemberFunctionResult0Return(
+    std::map<std::string, CommandData>::const_iterator commandIt, size_t initialSkipCount, bool definition ) const;
+  std::string
     constructRAIIHandleMemberFunctionResult1Return( std::map<std::string, CommandData>::const_iterator commandIt,
                                                     size_t                                             initialSkipCount,
-                                                    size_t returnParamIndex ) const;
-  std::tuple<bool, std::string, std::string>
+                                                    size_t                                             returnParamIndex,
+                                                    bool definition ) const;
+  std::string
     constructRAIIHandleMemberFunctionResult2Return( std::map<std::string, CommandData>::const_iterator commandIt,
                                                     size_t                                             initialSkipCount,
-                                                    std::vector<size_t> const & returnParamIndices ) const;
-  std::tuple<bool, std::string, std::string>
+                                                    std::vector<size_t> const & returnParamIndices,
+                                                    bool                        definition ) const;
+  std::string
     constructRAIIHandleMemberFunctionResult3Return( std::map<std::string, CommandData>::const_iterator commandIt,
                                                     size_t                                             initialSkipCount,
-                                                    std::vector<size_t> const & returnParamIndices ) const;
-  std::pair<std::string, std::string>
-    constructRAIIHandleMemberFunctions( std::pair<std::string, HandleData> const & handle,
-                                        std::set<std::string> const &              specialFunctions ) const;
-  std::pair<std::string, std::string>
-    constructRAIIHandleMemberFunctionType( std::map<std::string, CommandData>::const_iterator commandIt,
-                                           size_t                                             initialSkipCount,
-                                           std::map<size_t, size_t> const & vectorParamIndices ) const;
-  std::pair<std::string, std::string>
-       constructRAIIHandleMemberFunctionVkType( std::map<std::string, CommandData>::const_iterator commandIt,
-                                                size_t                                             initialSkipCount,
-                                                std::map<size_t, size_t> const & vectorParamIndices ) const;
-  bool constructRAIIHandleMemberFunctionValue( std::string &                                      functionDeclarations,
-                                               std::string &                                      functionDefinitions,
-                                               std::map<std::string, CommandData>::const_iterator commandIt,
-                                               size_t initialSkipCount ) const;
-  std::tuple<bool, std::string, std::string>
-       constructRAIIHandleMemberFunctionValue0Return( std::map<std::string, CommandData>::const_iterator commandIt,
-                                                      size_t initialSkipCount ) const;
-  bool constructRAIIHandleMemberFunctionVoid( std::string &                                      functionDeclarations,
-                                              std::string &                                      functionDefinitions,
-                                              std::map<std::string, CommandData>::const_iterator commandIt,
-                                              size_t initialSkipCount ) const;
-  std::tuple<bool, std::string, std::string>
-    constructRAIIHandleMemberFunctionVoid0Return( std::map<std::string, CommandData>::const_iterator commandIt,
-                                                  size_t initialSkipCount ) const;
-  std::tuple<bool, std::string, std::string>
+                                                    std::vector<size_t> const & returnParamIndices,
+                                                    bool                        definition ) const;
+  std::string constructRAIIHandleMemberFunctionDeclarations( std::pair<std::string, HandleData> const & handle,
+                                                             std::set<std::string> const & specialFunctions ) const;
+  std::string constructRAIIHandleMemberFunctionType( std::map<std::string, CommandData>::const_iterator commandIt,
+                                                     size_t                           initialSkipCount,
+                                                     std::map<size_t, size_t> const & vectorParamIndices,
+                                                     bool                             definition ) const;
+  std::string constructRAIIHandleMemberFunctionVkType( std::map<std::string, CommandData>::const_iterator commandIt,
+                                                       size_t                           initialSkipCount,
+                                                       std::map<size_t, size_t> const & vectorParamIndices,
+                                                       bool                             definition ) const;
+  std::string constructRAIIHandleMemberFunctionValue( std::map<std::string, CommandData>::const_iterator commandIt,
+                                                      size_t initialSkipCount,
+                                                      bool   definition ) const;
+  std::string constructRAIIHandleMemberFunctionValue0Return(
+    std::map<std::string, CommandData>::const_iterator commandIt, size_t initialSkipCount, bool definition ) const;
+  std::string constructRAIIHandleMemberFunctionVoid( std::map<std::string, CommandData>::const_iterator commandIt,
+                                                     size_t initialSkipCount,
+                                                     bool   definition ) const;
+  std::string constructRAIIHandleMemberFunctionVoid0Return(
+    std::map<std::string, CommandData>::const_iterator commandIt, size_t initialSkipCount, bool definition ) const;
+  std::string
     constructRAIIHandleMemberFunctionVoid1Return( std::map<std::string, CommandData>::const_iterator commandIt,
                                                   size_t                                             initialSkipCount,
-                                                  size_t returnParamIndex ) const;
-  std::tuple<bool, std::string, std::string>
+                                                  size_t                                             returnParamIndex,
+                                                  bool                                               definition ) const;
+  std::string
     constructRAIIHandleMemberFunctionVoid2Return( std::map<std::string, CommandData>::const_iterator commandIt,
                                                   size_t                                             initialSkipCount,
-                                                  std::vector<size_t> const & returnParamIndices ) const;
-  std::pair<std::string, std::string>
+                                                  std::vector<size_t> const &                        returnParamIndices,
+                                                  bool                                               definition ) const;
+  std::string
     constructRAIIHandleMemberFunctionVoidEnumerate( std::map<std::string, CommandData>::const_iterator commandIt,
                                                     size_t                                             initialSkipCount,
                                                     std::map<size_t, size_t> const & vectorParamIndices,
-                                                    std::vector<size_t> const & nonConstPointerParamIndices ) const;
-  std::pair<std::string, std::string> constructRAIIHandleMemberFunctionVoidEnumerateChain(
-    std::map<std::string, CommandData>::const_iterator commandIt,
-    size_t                                             initialSkipCount,
-    std::map<size_t, size_t> const &                   vectorParamIndices,
-    std::vector<size_t> const &                        nonConstPointerParamIndices ) const;
-  std::pair<std::string, std::string>
+                                                    std::vector<size_t> const &      nonConstPointerParamIndices,
+                                                    bool                             definition ) const;
+  std::string
+    constructRAIIHandleMemberFunctionVoidEnumerateChain( std::map<std::string, CommandData>::const_iterator commandIt,
+                                                         size_t                           initialSkipCount,
+                                                         std::map<size_t, size_t> const & vectorParamIndices,
+                                                         std::vector<size_t> const &      nonConstPointerParamIndices,
+                                                         bool                             definition ) const;
+  std::string
     constructRAIIHandleMemberFunctionVoidGetChain( std::map<std::string, CommandData>::const_iterator commandIt,
                                                    size_t                                             initialSkipCount,
                                                    std::map<size_t, size_t> const & vectorParamIndices,
-                                                   std::vector<size_t> const &      nonConstPointerParamIndices ) const;
-  std::pair<std::string, std::string>
+                                                   std::vector<size_t> const &      nonConstPointerParamIndices,
+                                                   bool                             definition ) const;
+  std::string
     constructRAIIHandleMemberFunctionVoidGetValue( std::map<std::string, CommandData>::const_iterator commandIt,
                                                    size_t                                             initialSkipCount,
                                                    std::map<size_t, size_t> const & vectorParamIndices,
-                                                   std::vector<size_t> const &      nonConstPointerParamIndices ) const;
+                                                   std::vector<size_t> const &      nonConstPointerParamIndices,
+                                                   bool                             definition ) const;
   std::string constructRAIIHandleSingularConstructorArguments(
     std::pair<std::string, HandleData> const &         handle,
     std::map<std::string, CommandData>::const_iterator constructorIt ) const;
@@ -1059,6 +1081,7 @@ private:
   std::string determineEnhancedReturnType( CommandData const & commandData,
                                            size_t              returnParamIndex,
                                            bool                isStructureChain ) const;
+  size_t      determineInitialSkipCount( std::string const & command ) const;
   std::vector<std::map<std::string, CommandData>::const_iterator>
     determineRAIIHandleConstructors( std::string const &                                handleType,
                                      std::map<std::string, CommandData>::const_iterator destructorIt,
@@ -1198,7 +1221,6 @@ private:
   void registerDeleter( std::string const & name, std::pair<std::string, CommandData> const & commandData );
   void renameFunctionParameters();
   void rescheduleRAIIHandle( std::string &                              str,
-                             std::string &                              commandDefinitions,
                              std::pair<std::string, HandleData> const & handle,
                              std::set<std::string> &                    listedHandles,
                              std::set<std::string> const &              specialFunctions ) const;
diff --git a/vulkan/vulkan.hpp b/vulkan/vulkan.hpp
index 4b7ce6f..abfd45a 100644
--- a/vulkan/vulkan.hpp
+++ b/vulkan/vulkan.hpp
@@ -2893,7 +2893,6 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
 #  if defined( VK_USE_PLATFORM_XLIB_KHR )
-
     //=== VK_KHR_xlib_surface ===
 
     VkResult vkCreateXlibSurfaceKHR( VkInstance                         instance,
@@ -2914,7 +2913,6 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VK_USE_PLATFORM_XLIB_KHR*/
 
 #  if defined( VK_USE_PLATFORM_XCB_KHR )
-
     //=== VK_KHR_xcb_surface ===
 
     VkResult vkCreateXcbSurfaceKHR( VkInstance                        instance,
@@ -2935,7 +2933,6 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VK_USE_PLATFORM_XCB_KHR*/
 
 #  if defined( VK_USE_PLATFORM_WAYLAND_KHR )
-
     //=== VK_KHR_wayland_surface ===
 
     VkResult vkCreateWaylandSurfaceKHR( VkInstance                            instance,
@@ -2955,7 +2952,6 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
 
 #  if defined( VK_USE_PLATFORM_ANDROID_KHR )
-
     //=== VK_KHR_android_surface ===
 
     VkResult vkCreateAndroidSurfaceKHR( VkInstance                            instance,
@@ -2968,7 +2964,6 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VK_USE_PLATFORM_ANDROID_KHR*/
 
 #  if defined( VK_USE_PLATFORM_WIN32_KHR )
-
     //=== VK_KHR_win32_surface ===
 
     VkResult vkCreateWin32SurfaceKHR( VkInstance                          instance,
@@ -3048,7 +3043,6 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
 #  if defined( VK_ENABLE_BETA_EXTENSIONS )
-
     //=== VK_KHR_video_queue ===
 
     VkResult vkGetPhysicalDeviceVideoCapabilitiesKHR( VkPhysicalDevice          physicalDevice,
@@ -3147,7 +3141,6 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #  if defined( VK_ENABLE_BETA_EXTENSIONS )
-
     //=== VK_KHR_video_decode_queue ===
 
     void vkCmdDecodeVideoKHR( VkCommandBuffer              commandBuffer,
@@ -3311,7 +3304,6 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
 #  if defined( VK_USE_PLATFORM_GGP )
-
     //=== VK_GGP_stream_descriptor_surface ===
 
     VkResult vkCreateStreamDescriptorSurfaceGGP( VkInstance                                     instance,
@@ -3340,7 +3332,6 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
 #  if defined( VK_USE_PLATFORM_WIN32_KHR )
-
     //=== VK_NV_external_memory_win32 ===
 
     VkResult vkGetMemoryWin32HandleNV( VkDevice                          device,
@@ -3437,7 +3428,6 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
 #  if defined( VK_USE_PLATFORM_VI_NN )
-
     //=== VK_NN_vi_surface ===
 
     VkResult vkCreateViSurfaceNN( VkInstance                      instance,
@@ -3481,7 +3471,6 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
 #  if defined( VK_USE_PLATFORM_WIN32_KHR )
-
     //=== VK_KHR_external_memory_win32 ===
 
     VkResult vkGetMemoryWin32HandleKHR( VkDevice                              device,
@@ -3529,7 +3518,6 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
 #  if defined( VK_USE_PLATFORM_WIN32_KHR )
-
     //=== VK_KHR_external_semaphore_win32 ===
 
     VkResult vkImportSemaphoreWin32HandleKHR(
@@ -3643,7 +3631,6 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
 #  if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
-
     //=== VK_EXT_acquire_xlib_display ===
 
     VkResult vkAcquireXlibDisplayEXT( VkPhysicalDevice physicalDevice,
@@ -3795,7 +3782,6 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
 #  if defined( VK_USE_PLATFORM_WIN32_KHR )
-
     //=== VK_KHR_external_fence_win32 ===
 
     VkResult vkImportFenceWin32HandleKHR(
@@ -3912,7 +3898,6 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
 #  if defined( VK_USE_PLATFORM_IOS_MVK )
-
     //=== VK_MVK_ios_surface ===
 
     VkResult vkCreateIOSSurfaceMVK( VkInstance                        instance,
@@ -3925,7 +3910,6 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VK_USE_PLATFORM_IOS_MVK*/
 
 #  if defined( VK_USE_PLATFORM_MACOS_MVK )
-
     //=== VK_MVK_macos_surface ===
 
     VkResult vkCreateMacOSSurfaceMVK( VkInstance                          instance,
@@ -4010,7 +3994,6 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
 #  if defined( VK_USE_PLATFORM_ANDROID_KHR )
-
     //=== VK_ANDROID_external_memory_android_hardware_buffer ===
 
     VkResult vkGetAndroidHardwareBufferPropertiesANDROID( VkDevice                                   device,
@@ -4672,7 +4655,6 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
 #  if defined( VK_USE_PLATFORM_FUCHSIA )
-
     //=== VK_FUCHSIA_imagepipe_surface ===
 
     VkResult vkCreateImagePipeSurfaceFUCHSIA( VkInstance                                  instance,
@@ -4685,7 +4667,6 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VK_USE_PLATFORM_FUCHSIA*/
 
 #  if defined( VK_USE_PLATFORM_METAL_EXT )
-
     //=== VK_EXT_metal_surface ===
 
     VkResult vkCreateMetalSurfaceEXT( VkInstance                          instance,
@@ -4756,7 +4737,6 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
 #  if defined( VK_USE_PLATFORM_WIN32_KHR )
-
     //=== VK_EXT_full_screen_exclusive ===
 
     VkResult vkGetPhysicalDeviceSurfacePresentModes2EXT( VkPhysicalDevice                        physicalDevice,
@@ -5067,7 +5047,6 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
 #  if defined( VK_ENABLE_BETA_EXTENSIONS )
-
     //=== VK_KHR_video_encode_queue ===
 
     void vkCmdEncodeVideoKHR( VkCommandBuffer              commandBuffer,
@@ -5190,7 +5169,6 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
 #  if defined( VK_USE_PLATFORM_WIN32_KHR )
-
     //=== VK_NV_acquire_winrt_display ===
 
     VkResult vkAcquireWinrtDisplayNV( VkPhysicalDevice physicalDevice, VkDisplayKHR display ) const VULKAN_HPP_NOEXCEPT
@@ -5207,7 +5185,6 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
 #  if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
-
     //=== VK_EXT_directfb_surface ===
 
     VkResult vkCreateDirectFBSurfaceEXT( VkInstance                             instance,
@@ -5326,7 +5303,6 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
 #  if defined( VK_USE_PLATFORM_FUCHSIA )
-
     //=== VK_FUCHSIA_external_memory ===
 
     VkResult vkGetMemoryZirconHandleFUCHSIA( VkDevice                                   device,
@@ -5348,7 +5324,6 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VK_USE_PLATFORM_FUCHSIA*/
 
 #  if defined( VK_USE_PLATFORM_FUCHSIA )
-
     //=== VK_FUCHSIA_external_semaphore ===
 
     VkResult vkImportSemaphoreZirconHandleFUCHSIA(
@@ -5397,7 +5372,6 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
 #  if defined( VK_USE_PLATFORM_SCREEN_QNX )
-
     //=== VK_QNX_screen_surface ===
 
     VkResult vkCreateScreenSurfaceQNX( VkInstance                           instance,
@@ -11009,7 +10983,6 @@ namespace VULKAN_HPP_NAMESPACE
   }
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
-
   //=== VK_KHR_video_queue ===
 
   enum class VideoCodecOperationFlagBitsKHR : VkVideoCodecOperationFlagsKHR
@@ -11166,7 +11139,6 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
-
   //=== VK_KHR_video_decode_queue ===
 
   enum class VideoDecodeFlagBitsKHR : VkVideoDecodeFlagsKHR
@@ -11187,7 +11159,6 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
-
   //=== VK_EXT_video_encode_h264 ===
 
   enum class VideoEncodeH264CapabilitiesFlagBitsEXT : VkVideoEncodeH264CapabilitiesFlagsEXT
@@ -11302,7 +11273,6 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
-
   //=== VK_EXT_video_decode_h264 ===
 
   enum class VideoDecodeH264FieldLayoutFlagBitsEXT : VkVideoDecodeH264FieldLayoutFlagsEXT
@@ -12410,7 +12380,6 @@ namespace VULKAN_HPP_NAMESPACE
   }
 
 #if defined( VK_USE_PLATFORM_WIN32_KHR )
-
   //=== VK_EXT_full_screen_exclusive ===
 
   enum class FullScreenExclusiveEXT
@@ -12576,7 +12545,6 @@ namespace VULKAN_HPP_NAMESPACE
   }
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
-
   //=== VK_KHR_video_encode_queue ===
 
   enum class VideoEncodeFlagBitsKHR : VkVideoEncodeFlagsKHR
@@ -16898,7 +16866,6 @@ namespace VULKAN_HPP_NAMESPACE
   }
 
 #if defined( VK_USE_PLATFORM_XLIB_KHR )
-
   //=== VK_KHR_xlib_surface ===
 
   enum class XlibSurfaceCreateFlagBitsKHR : VkFlags
@@ -16919,7 +16886,6 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VK_USE_PLATFORM_XLIB_KHR*/
 
 #if defined( VK_USE_PLATFORM_XCB_KHR )
-
   //=== VK_KHR_xcb_surface ===
 
   enum class XcbSurfaceCreateFlagBitsKHR : VkFlags
@@ -16940,7 +16906,6 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VK_USE_PLATFORM_XCB_KHR*/
 
 #if defined( VK_USE_PLATFORM_WAYLAND_KHR )
-
   //=== VK_KHR_wayland_surface ===
 
   enum class WaylandSurfaceCreateFlagBitsKHR : VkFlags
@@ -16961,7 +16926,6 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
 
 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
-
   //=== VK_KHR_android_surface ===
 
   enum class AndroidSurfaceCreateFlagBitsKHR : VkFlags
@@ -16982,7 +16946,6 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
 
 #if defined( VK_USE_PLATFORM_WIN32_KHR )
-
   //=== VK_KHR_win32_surface ===
 
   enum class Win32SurfaceCreateFlagBitsKHR : VkFlags
@@ -17061,7 +17024,6 @@ namespace VULKAN_HPP_NAMESPACE
   }
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
-
   //=== VK_KHR_video_queue ===
 
   using VideoCodecOperationFlagsKHR = Flags<VideoCodecOperationFlagBitsKHR>;
@@ -17461,7 +17423,6 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
-
   //=== VK_KHR_video_decode_queue ===
 
   using VideoDecodeFlagsKHR = Flags<VideoDecodeFlagBitsKHR>;
@@ -17530,7 +17491,6 @@ namespace VULKAN_HPP_NAMESPACE
   }
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
-
   //=== VK_EXT_video_encode_h264 ===
 
   using VideoEncodeH264CapabilitiesFlagsEXT = Flags<VideoEncodeH264CapabilitiesFlagBitsEXT>;
@@ -17763,7 +17723,6 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
-
   //=== VK_EXT_video_decode_h264 ===
 
   using VideoDecodeH264FieldLayoutFlagsEXT = Flags<VideoDecodeH264FieldLayoutFlagBitsEXT>;
@@ -17834,7 +17793,6 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_USE_PLATFORM_GGP )
-
   //=== VK_GGP_stream_descriptor_surface ===
 
   enum class StreamDescriptorSurfaceCreateFlagBitsGGP : VkFlags
@@ -17964,7 +17922,6 @@ namespace VULKAN_HPP_NAMESPACE
   }
 
 #if defined( VK_USE_PLATFORM_VI_NN )
-
   //=== VK_NN_vi_surface ===
 
   enum class ViSurfaceCreateFlagBitsNN : VkFlags
@@ -18212,7 +18169,6 @@ namespace VULKAN_HPP_NAMESPACE
   }
 
 #if defined( VK_USE_PLATFORM_IOS_MVK )
-
   //=== VK_MVK_ios_surface ===
 
   enum class IOSSurfaceCreateFlagBitsMVK : VkFlags
@@ -18233,7 +18189,6 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VK_USE_PLATFORM_IOS_MVK*/
 
 #if defined( VK_USE_PLATFORM_MACOS_MVK )
-
   //=== VK_MVK_macos_surface ===
 
   enum class MacOSSurfaceCreateFlagBitsMVK : VkFlags
@@ -18672,7 +18627,6 @@ namespace VULKAN_HPP_NAMESPACE
   }
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
-
   //=== VK_EXT_video_decode_h265 ===
 
   enum class VideoDecodeH265CreateFlagBitsEXT : VkFlags
@@ -18747,7 +18701,6 @@ namespace VULKAN_HPP_NAMESPACE
   }
 
 #if defined( VK_USE_PLATFORM_FUCHSIA )
-
   //=== VK_FUCHSIA_imagepipe_surface ===
 
   enum class ImagePipeSurfaceCreateFlagBitsFUCHSIA : VkFlags
@@ -18768,7 +18721,6 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 
 #if defined( VK_USE_PLATFORM_METAL_EXT )
-
   //=== VK_EXT_metal_surface ===
 
   enum class MetalSurfaceCreateFlagBitsEXT : VkFlags
@@ -19024,7 +18976,6 @@ namespace VULKAN_HPP_NAMESPACE
   }
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
-
   //=== VK_KHR_video_encode_queue ===
 
   using VideoEncodeFlagsKHR = Flags<VideoEncodeFlagBitsKHR>;
@@ -19563,7 +19514,6 @@ namespace VULKAN_HPP_NAMESPACE
   }
 
 #if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
-
   //=== VK_EXT_directfb_surface ===
 
   enum class DirectFBSurfaceCreateFlagBitsEXT : VkFlags
@@ -19584,7 +19534,6 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
 
 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
-
   //=== VK_QNX_screen_surface ===
 
   enum class ScreenSurfaceCreateFlagBitsQNX : VkFlags
@@ -37502,6 +37451,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+    //=== VK_VERSION_1_0 ===
+
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD Result
       begin( const VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo * pBeginInfo,
@@ -37513,101 +37464,90 @@ namespace VULKAN_HPP_NAMESPACE
              Dispatch const & d             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void beginConditionalRenderingEXT(
-      const VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT * pConditionalRenderingBegin,
-      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    VULKAN_HPP_NODISCARD Result
+      end( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#else
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void beginConditionalRenderingEXT( const ConditionalRenderingBeginInfoEXT & conditionalRenderingBegin,
-                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
-      VULKAN_HPP_NOEXCEPT;
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
+      end( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      reset( VULKAN_HPP_NAMESPACE::CommandBufferResetFlags flags,
+             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#else
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    typename ResultValueType<void>::type
+         reset( VULKAN_HPP_NAMESPACE::CommandBufferResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
+                Dispatch const & d                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void
-      beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo,
-                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+    void bindPipeline( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
+                       VULKAN_HPP_NAMESPACE::Pipeline          pipeline,
+                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void setViewport( uint32_t                               firstViewport,
+                      uint32_t                               viewportCount,
+                      const VULKAN_HPP_NAMESPACE::Viewport * pViewports,
+                      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
-      beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo,
-                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+    void setViewport( uint32_t                                                 firstViewport,
+                      ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports,
+                      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 beginQuery( VULKAN_HPP_NAMESPACE::QueryPool         queryPool,
-                     uint32_t                                query,
-                     VULKAN_HPP_NAMESPACE::QueryControlFlags flags,
+    void setScissor( uint32_t                             firstScissor,
+                     uint32_t                             scissorCount,
+                     const VULKAN_HPP_NAMESPACE::Rect2D * pScissors,
                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void beginQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool         queryPool,
-                               uint32_t                                query,
-                               VULKAN_HPP_NAMESPACE::QueryControlFlags flags,
-                               uint32_t                                index,
-                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void beginRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo * pRenderPassBegin,
-                          VULKAN_HPP_NAMESPACE::SubpassContents             contents,
-                          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 beginRenderPass( const RenderPassBeginInfo &           renderPassBegin,
-                          VULKAN_HPP_NAMESPACE::SubpassContents contents,
-                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+    void setScissor( uint32_t                                               firstScissor,
+                     ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors,
+                     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 beginRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo * pRenderPassBegin,
-                           const VULKAN_HPP_NAMESPACE::SubpassBeginInfo *    pSubpassBeginInfo,
-                           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 beginRenderPass2( const RenderPassBeginInfo & renderPassBegin,
-                           const SubpassBeginInfo &    subpassBeginInfo,
-                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+    void setLineWidth( float              lineWidth,
+                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void beginRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo * pRenderPassBegin,
-                              const VULKAN_HPP_NAMESPACE::SubpassBeginInfo *    pSubpassBeginInfo,
-                              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 beginRenderPass2KHR( const RenderPassBeginInfo & renderPassBegin,
-                              const SubpassBeginInfo &    subpassBeginInfo,
-                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+    void setDepthBias( float              depthBiasConstantFactor,
+                       float              depthBiasClamp,
+                       float              depthBiasSlopeFactor,
+                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void beginTransformFeedbackEXT( uint32_t                                 firstCounterBuffer,
-                                    uint32_t                                 counterBufferCount,
-                                    const VULKAN_HPP_NAMESPACE::Buffer *     pCounterBuffers,
-                                    const VULKAN_HPP_NAMESPACE::DeviceSize * pCounterBufferOffsets,
-                                    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 beginTransformFeedbackEXT( uint32_t                                               firstCounterBuffer,
-                                    ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & counterBuffers,
-                                    ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets
-                                                       VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
-      VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+    void setBlendConstants( const float        blendConstants[4],
+                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 
-#if defined( VK_ENABLE_BETA_EXTENSIONS )
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void beginVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR * pBeginInfo,
-                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    void setDepthBounds( float              minDepthBounds,
+                         float              maxDepthBounds,
+                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void beginVideoCodingKHR( const VideoBeginCodingInfoKHR & beginInfo,
+    void setStencilCompareMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
+                                uint32_t                               compareMask,
+                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void setStencilWriteMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
+                              uint32_t                               writeMask,
+                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void setStencilReference( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
+                              uint32_t                               reference,
                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_ENABLE_BETA_EXTENSIONS*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     void bindDescriptorSets( VULKAN_HPP_NAMESPACE::PipelineBindPoint     pipelineBindPoint,
@@ -37634,42 +37574,6 @@ namespace VULKAN_HPP_NAMESPACE
                           VULKAN_HPP_NAMESPACE::IndexType  indexType,
                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void bindPipeline( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
-                       VULKAN_HPP_NAMESPACE::Pipeline          pipeline,
-                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void bindPipelineShaderGroupNV( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
-                                    VULKAN_HPP_NAMESPACE::Pipeline          pipeline,
-                                    uint32_t                                groupIndex,
-                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
-      VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void
-      bindShadingRateImageNV( VULKAN_HPP_NAMESPACE::ImageView   imageView,
-                              VULKAN_HPP_NAMESPACE::ImageLayout imageLayout,
-                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void bindTransformFeedbackBuffersEXT( uint32_t                                 firstBinding,
-                                          uint32_t                                 bindingCount,
-                                          const VULKAN_HPP_NAMESPACE::Buffer *     pBuffers,
-                                          const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets,
-                                          const VULKAN_HPP_NAMESPACE::DeviceSize * pSizes,
-                                          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 bindTransformFeedbackBuffersEXT(
-      uint32_t                                                         firstBinding,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &           buffers,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const &       offsets,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     void bindVertexBuffers( uint32_t                                 firstBinding,
                             uint32_t                                 bindingCount,
@@ -37686,22 +37590,75 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void bindVertexBuffers2EXT( uint32_t                                 firstBinding,
-                                uint32_t                                 bindingCount,
-                                const VULKAN_HPP_NAMESPACE::Buffer *     pBuffers,
-                                const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets,
-                                const VULKAN_HPP_NAMESPACE::DeviceSize * pSizes,
-                                const VULKAN_HPP_NAMESPACE::DeviceSize * pStrides,
-                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+    void draw( uint32_t           vertexCount,
+               uint32_t           instanceCount,
+               uint32_t           firstVertex,
+               uint32_t           firstInstance,
+               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void drawIndexed( uint32_t           indexCount,
+                      uint32_t           instanceCount,
+                      uint32_t           firstIndex,
+                      int32_t            vertexOffset,
+                      uint32_t           firstInstance,
+                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void drawIndirect( VULKAN_HPP_NAMESPACE::Buffer     buffer,
+                       VULKAN_HPP_NAMESPACE::DeviceSize offset,
+                       uint32_t                         drawCount,
+                       uint32_t                         stride,
+                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void drawIndexedIndirect( VULKAN_HPP_NAMESPACE::Buffer     buffer,
+                              VULKAN_HPP_NAMESPACE::DeviceSize offset,
+                              uint32_t                         drawCount,
+                              uint32_t                         stride,
+                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void dispatch( uint32_t           groupCountX,
+                   uint32_t           groupCountY,
+                   uint32_t           groupCountZ,
+                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void dispatchIndirect( VULKAN_HPP_NAMESPACE::Buffer     buffer,
+                           VULKAN_HPP_NAMESPACE::DeviceSize offset,
+                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void copyBuffer( VULKAN_HPP_NAMESPACE::Buffer             srcBuffer,
+                     VULKAN_HPP_NAMESPACE::Buffer             dstBuffer,
+                     uint32_t                                 regionCount,
+                     const VULKAN_HPP_NAMESPACE::BufferCopy * pRegions,
+                     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 bindVertexBuffers2EXT(
-      uint32_t                                                           firstBinding,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &             buffers,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const &         offsets,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & strides VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
+    void copyBuffer( VULKAN_HPP_NAMESPACE::Buffer                               srcBuffer,
+                     VULKAN_HPP_NAMESPACE::Buffer                               dstBuffer,
+                     ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferCopy> const & regions,
+                     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 copyImage( VULKAN_HPP_NAMESPACE::Image             srcImage,
+                    VULKAN_HPP_NAMESPACE::ImageLayout       srcImageLayout,
+                    VULKAN_HPP_NAMESPACE::Image             dstImage,
+                    VULKAN_HPP_NAMESPACE::ImageLayout       dstImageLayout,
+                    uint32_t                                regionCount,
+                    const VULKAN_HPP_NAMESPACE::ImageCopy * pRegions,
+                    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 copyImage( VULKAN_HPP_NAMESPACE::Image                               srcImage,
+                    VULKAN_HPP_NAMESPACE::ImageLayout                         srcImageLayout,
+                    VULKAN_HPP_NAMESPACE::Image                               dstImage,
+                    VULKAN_HPP_NAMESPACE::ImageLayout                         dstImageLayout,
+                    ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageCopy> const & regions,
+                    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>
@@ -37725,83 +37682,57 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void blitImage2KHR( const VULKAN_HPP_NAMESPACE::BlitImageInfo2KHR * pBlitImageInfo,
-                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+    void copyBufferToImage( VULKAN_HPP_NAMESPACE::Buffer                  srcBuffer,
+                            VULKAN_HPP_NAMESPACE::Image                   dstImage,
+                            VULKAN_HPP_NAMESPACE::ImageLayout             dstImageLayout,
+                            uint32_t                                      regionCount,
+                            const VULKAN_HPP_NAMESPACE::BufferImageCopy * pRegions,
+                            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 blitImage2KHR( const BlitImageInfo2KHR & blitImageInfo,
-                        Dispatch const & d        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+    void copyBufferToImage( VULKAN_HPP_NAMESPACE::Buffer                                    srcBuffer,
+                            VULKAN_HPP_NAMESPACE::Image                                     dstImage,
+                            VULKAN_HPP_NAMESPACE::ImageLayout                               dstImageLayout,
+                            ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions,
+                            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 buildAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV * pInfo,
-                                       VULKAN_HPP_NAMESPACE::Buffer                              instanceData,
-                                       VULKAN_HPP_NAMESPACE::DeviceSize                          instanceOffset,
-                                       VULKAN_HPP_NAMESPACE::Bool32                              update,
-                                       VULKAN_HPP_NAMESPACE::AccelerationStructureNV             dst,
-                                       VULKAN_HPP_NAMESPACE::AccelerationStructureNV             src,
-                                       VULKAN_HPP_NAMESPACE::Buffer                              scratch,
-                                       VULKAN_HPP_NAMESPACE::DeviceSize                          scratchOffset,
-                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
-      VULKAN_HPP_NOEXCEPT;
+    void copyImageToBuffer( VULKAN_HPP_NAMESPACE::Image                   srcImage,
+                            VULKAN_HPP_NAMESPACE::ImageLayout             srcImageLayout,
+                            VULKAN_HPP_NAMESPACE::Buffer                  dstBuffer,
+                            uint32_t                                      regionCount,
+                            const VULKAN_HPP_NAMESPACE::BufferImageCopy * pRegions,
+                            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 buildAccelerationStructureNV( const AccelerationStructureInfoNV &           info,
-                                       VULKAN_HPP_NAMESPACE::Buffer                  instanceData,
-                                       VULKAN_HPP_NAMESPACE::DeviceSize              instanceOffset,
-                                       VULKAN_HPP_NAMESPACE::Bool32                  update,
-                                       VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst,
-                                       VULKAN_HPP_NAMESPACE::AccelerationStructureNV src,
-                                       VULKAN_HPP_NAMESPACE::Buffer                  scratch,
-                                       VULKAN_HPP_NAMESPACE::DeviceSize              scratchOffset,
-                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
-      VULKAN_HPP_NOEXCEPT;
+    void copyImageToBuffer( VULKAN_HPP_NAMESPACE::Image                                     srcImage,
+                            VULKAN_HPP_NAMESPACE::ImageLayout                               srcImageLayout,
+                            VULKAN_HPP_NAMESPACE::Buffer                                    dstBuffer,
+                            ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions,
+                            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 buildAccelerationStructuresIndirectKHR(
-      uint32_t                                                                infoCount,
-      const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR * pInfos,
-      const VULKAN_HPP_NAMESPACE::DeviceAddress *                             pIndirectDeviceAddresses,
-      const uint32_t *                                                        pIndirectStrides,
-      const uint32_t * const *                                                ppMaxPrimitiveCounts,
-      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+    void updateBuffer( VULKAN_HPP_NAMESPACE::Buffer     dstBuffer,
+                       VULKAN_HPP_NAMESPACE::DeviceSize dstOffset,
+                       VULKAN_HPP_NAMESPACE::DeviceSize dataSize,
+                       const void *                     pData,
+                       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 buildAccelerationStructuresIndirectKHR(
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceAddress> const &                             indirectDeviceAddresses,
-      ArrayProxy<const uint32_t> const &                                                        indirectStrides,
-      ArrayProxy<const uint32_t * const> const &                                                pMaxPrimitiveCounts,
-      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
+    template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void updateBuffer( VULKAN_HPP_NAMESPACE::Buffer     dstBuffer,
+                       VULKAN_HPP_NAMESPACE::DeviceSize dstOffset,
+                       ArrayProxy<const T> const &      data,
+                       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 buildAccelerationStructuresKHR(
-      uint32_t                                                                     infoCount,
-      const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR *      pInfos,
-      const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos,
-      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 buildAccelerationStructuresKHR(
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const &      infos,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos,
-      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void clearAttachments( uint32_t                                      attachmentCount,
-                           const VULKAN_HPP_NAMESPACE::ClearAttachment * pAttachments,
-                           uint32_t                                      rectCount,
-                           const VULKAN_HPP_NAMESPACE::ClearRect *       pRects,
-                           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 clearAttachments( ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearAttachment> const & attachments,
-                           ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearRect> const &       rects,
-                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+    void fillBuffer( VULKAN_HPP_NAMESPACE::Buffer     dstBuffer,
+                     VULKAN_HPP_NAMESPACE::DeviceSize dstOffset,
+                     VULKAN_HPP_NAMESPACE::DeviceSize size,
+                     uint32_t                         data,
+                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     void clearColorImage( VULKAN_HPP_NAMESPACE::Image                         image,
@@ -37837,599 +37768,19 @@ namespace VULKAN_HPP_NAMESPACE
                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
-#if defined( VK_ENABLE_BETA_EXTENSIONS )
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void controlVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR * pCodingControlInfo,
-                                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 controlVideoCodingKHR( const VideoCodingControlInfoKHR & codingControlInfo,
-                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_ENABLE_BETA_EXTENSIONS*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void copyAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR * pInfo,
-                                       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 copyAccelerationStructureKHR( const CopyAccelerationStructureInfoKHR & info,
-                                       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 copyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV          dst,
-                                      VULKAN_HPP_NAMESPACE::AccelerationStructureNV          src,
-                                      VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR mode,
-                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
-      VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void copyAccelerationStructureToMemoryKHR(
-      const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR * pInfo,
-      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 copyAccelerationStructureToMemoryKHR( const CopyAccelerationStructureToMemoryInfoKHR & info,
-                                               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 copyBuffer( VULKAN_HPP_NAMESPACE::Buffer             srcBuffer,
-                     VULKAN_HPP_NAMESPACE::Buffer             dstBuffer,
-                     uint32_t                                 regionCount,
-                     const VULKAN_HPP_NAMESPACE::BufferCopy * pRegions,
-                     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 copyBuffer( VULKAN_HPP_NAMESPACE::Buffer                               srcBuffer,
-                     VULKAN_HPP_NAMESPACE::Buffer                               dstBuffer,
-                     ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferCopy> const & regions,
-                     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 copyBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2KHR * pCopyBufferInfo,
-                         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 copyBuffer2KHR( const CopyBufferInfo2KHR & copyBufferInfo,
-                         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 copyBufferToImage( VULKAN_HPP_NAMESPACE::Buffer                  srcBuffer,
-                            VULKAN_HPP_NAMESPACE::Image                   dstImage,
-                            VULKAN_HPP_NAMESPACE::ImageLayout             dstImageLayout,
-                            uint32_t                                      regionCount,
-                            const VULKAN_HPP_NAMESPACE::BufferImageCopy * pRegions,
-                            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 copyBufferToImage( VULKAN_HPP_NAMESPACE::Buffer                                    srcBuffer,
-                            VULKAN_HPP_NAMESPACE::Image                                     dstImage,
-                            VULKAN_HPP_NAMESPACE::ImageLayout                               dstImageLayout,
-                            ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions,
-                            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 copyBufferToImage2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2KHR * pCopyBufferToImageInfo,
-                                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 copyBufferToImage2KHR( const CopyBufferToImageInfo2KHR & copyBufferToImageInfo,
-                                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 copyImage( VULKAN_HPP_NAMESPACE::Image             srcImage,
-                    VULKAN_HPP_NAMESPACE::ImageLayout       srcImageLayout,
-                    VULKAN_HPP_NAMESPACE::Image             dstImage,
-                    VULKAN_HPP_NAMESPACE::ImageLayout       dstImageLayout,
-                    uint32_t                                regionCount,
-                    const VULKAN_HPP_NAMESPACE::ImageCopy * pRegions,
-                    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 copyImage( VULKAN_HPP_NAMESPACE::Image                               srcImage,
-                    VULKAN_HPP_NAMESPACE::ImageLayout                         srcImageLayout,
-                    VULKAN_HPP_NAMESPACE::Image                               dstImage,
-                    VULKAN_HPP_NAMESPACE::ImageLayout                         dstImageLayout,
-                    ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageCopy> const & regions,
-                    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 copyImage2KHR( const VULKAN_HPP_NAMESPACE::CopyImageInfo2KHR * pCopyImageInfo,
-                        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 copyImage2KHR( const CopyImageInfo2KHR & copyImageInfo,
-                        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 copyImageToBuffer( VULKAN_HPP_NAMESPACE::Image                   srcImage,
-                            VULKAN_HPP_NAMESPACE::ImageLayout             srcImageLayout,
-                            VULKAN_HPP_NAMESPACE::Buffer                  dstBuffer,
-                            uint32_t                                      regionCount,
-                            const VULKAN_HPP_NAMESPACE::BufferImageCopy * pRegions,
-                            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 copyImageToBuffer( VULKAN_HPP_NAMESPACE::Image                                     srcImage,
-                            VULKAN_HPP_NAMESPACE::ImageLayout                               srcImageLayout,
-                            VULKAN_HPP_NAMESPACE::Buffer                                    dstBuffer,
-                            ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions,
-                            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 copyImageToBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2KHR * pCopyImageToBufferInfo,
-                                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 copyImageToBuffer2KHR( const CopyImageToBufferInfo2KHR & copyImageToBufferInfo,
-                                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 copyMemoryToAccelerationStructureKHR(
-      const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR * pInfo,
-      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 copyMemoryToAccelerationStructureKHR( const CopyMemoryToAccelerationStructureInfoKHR & info,
-                                               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 copyQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool        queryPool,
-                               uint32_t                               firstQuery,
-                               uint32_t                               queryCount,
-                               VULKAN_HPP_NAMESPACE::Buffer           dstBuffer,
-                               VULKAN_HPP_NAMESPACE::DeviceSize       dstOffset,
-                               VULKAN_HPP_NAMESPACE::DeviceSize       stride,
-                               VULKAN_HPP_NAMESPACE::QueryResultFlags flags,
-                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void cuLaunchKernelNVX( const VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX * pLaunchInfo,
-                            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 cuLaunchKernelNVX( const CuLaunchInfoNVX & launchInfo,
-                            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 debugMarkerBeginEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT * pMarkerInfo,
-                              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 debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT & markerInfo,
-                              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 debugMarkerEndEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void debugMarkerInsertEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT * pMarkerInfo,
-                               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 debugMarkerInsertEXT( const DebugMarkerMarkerInfoEXT & markerInfo,
-                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#if defined( VK_ENABLE_BETA_EXTENSIONS )
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void decodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR * pFrameInfo,
-                         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 decodeVideoKHR( const VideoDecodeInfoKHR & frameInfo,
-                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_ENABLE_BETA_EXTENSIONS*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void dispatch( uint32_t           groupCountX,
-                   uint32_t           groupCountY,
-                   uint32_t           groupCountZ,
-                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void dispatchBase( uint32_t           baseGroupX,
-                       uint32_t           baseGroupY,
-                       uint32_t           baseGroupZ,
-                       uint32_t           groupCountX,
-                       uint32_t           groupCountY,
-                       uint32_t           groupCountZ,
-                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void dispatchBaseKHR( uint32_t           baseGroupX,
-                          uint32_t           baseGroupY,
-                          uint32_t           baseGroupZ,
-                          uint32_t           groupCountX,
-                          uint32_t           groupCountY,
-                          uint32_t           groupCountZ,
-                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void dispatchIndirect( VULKAN_HPP_NAMESPACE::Buffer     buffer,
-                           VULKAN_HPP_NAMESPACE::DeviceSize offset,
+    void clearAttachments( uint32_t                                      attachmentCount,
+                           const VULKAN_HPP_NAMESPACE::ClearAttachment * pAttachments,
+                           uint32_t                                      rectCount,
+                           const VULKAN_HPP_NAMESPACE::ClearRect *       pRects,
                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void draw( uint32_t           vertexCount,
-               uint32_t           instanceCount,
-               uint32_t           firstVertex,
-               uint32_t           firstInstance,
-               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void drawIndexed( uint32_t           indexCount,
-                      uint32_t           instanceCount,
-                      uint32_t           firstIndex,
-                      int32_t            vertexOffset,
-                      uint32_t           firstInstance,
-                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void drawIndexedIndirect( VULKAN_HPP_NAMESPACE::Buffer     buffer,
-                              VULKAN_HPP_NAMESPACE::DeviceSize offset,
-                              uint32_t                         drawCount,
-                              uint32_t                         stride,
-                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void
-      drawIndexedIndirectCount( VULKAN_HPP_NAMESPACE::Buffer     buffer,
-                                VULKAN_HPP_NAMESPACE::DeviceSize offset,
-                                VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
-                                VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
-                                uint32_t                         maxDrawCount,
-                                uint32_t                         stride,
-                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void drawIndexedIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer     buffer,
-                                      VULKAN_HPP_NAMESPACE::DeviceSize offset,
-                                      VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
-                                      VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
-                                      uint32_t                         maxDrawCount,
-                                      uint32_t                         stride,
-                                      Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
-      VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void drawIndexedIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer     buffer,
-                                      VULKAN_HPP_NAMESPACE::DeviceSize offset,
-                                      VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
-                                      VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
-                                      uint32_t                         maxDrawCount,
-                                      uint32_t                         stride,
-                                      Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
-      VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void drawIndirect( VULKAN_HPP_NAMESPACE::Buffer     buffer,
-                       VULKAN_HPP_NAMESPACE::DeviceSize offset,
-                       uint32_t                         drawCount,
-                       uint32_t                         stride,
-                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void
-      drawIndirectByteCountEXT( uint32_t                         instanceCount,
-                                uint32_t                         firstInstance,
-                                VULKAN_HPP_NAMESPACE::Buffer     counterBuffer,
-                                VULKAN_HPP_NAMESPACE::DeviceSize counterBufferOffset,
-                                uint32_t                         counterOffset,
-                                uint32_t                         vertexStride,
-                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void drawIndirectCount( VULKAN_HPP_NAMESPACE::Buffer     buffer,
-                            VULKAN_HPP_NAMESPACE::DeviceSize offset,
-                            VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
-                            VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
-                            uint32_t                         maxDrawCount,
-                            uint32_t                         stride,
-                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void drawIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer     buffer,
-                               VULKAN_HPP_NAMESPACE::DeviceSize offset,
-                               VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
-                               VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
-                               uint32_t                         maxDrawCount,
-                               uint32_t                         stride,
-                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void drawIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer     buffer,
-                               VULKAN_HPP_NAMESPACE::DeviceSize offset,
-                               VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
-                               VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
-                               uint32_t                         maxDrawCount,
-                               uint32_t                         stride,
-                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void drawMeshTasksIndirectCountNV( VULKAN_HPP_NAMESPACE::Buffer     buffer,
-                                       VULKAN_HPP_NAMESPACE::DeviceSize offset,
-                                       VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
-                                       VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
-                                       uint32_t                         maxDrawCount,
-                                       uint32_t                         stride,
-                                       Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
-      VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void
-      drawMeshTasksIndirectNV( VULKAN_HPP_NAMESPACE::Buffer     buffer,
-                               VULKAN_HPP_NAMESPACE::DeviceSize offset,
-                               uint32_t                         drawCount,
-                               uint32_t                         stride,
-                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void drawMeshTasksNV( uint32_t           taskCount,
-                          uint32_t           firstTask,
-                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-#if defined( VK_ENABLE_BETA_EXTENSIONS )
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void encodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR * pEncodeInfo,
-                         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 encodeVideoKHR( const VideoEncodeInfoKHR & encodeInfo,
-                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_ENABLE_BETA_EXTENSIONS*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void endConditionalRenderingEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
-      VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void endDebugUtilsLabelEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void endQuery( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
-                   uint32_t                        query,
-                   Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void endQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
-                             uint32_t                        query,
-                             uint32_t                        index,
-                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void endRenderPass( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void endRenderPass2( const VULKAN_HPP_NAMESPACE::SubpassEndInfo * pSubpassEndInfo,
-                         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 endRenderPass2( const SubpassEndInfo & subpassEndInfo,
-                         Dispatch const & d     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+    void clearAttachments( ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearAttachment> const & attachments,
+                           ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearRect> const &       rects,
+                           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 endRenderPass2KHR( const VULKAN_HPP_NAMESPACE::SubpassEndInfo * pSubpassEndInfo,
-                            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 endRenderPass2KHR( const SubpassEndInfo & subpassEndInfo,
-                            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
-      endTransformFeedbackEXT( uint32_t                                 firstCounterBuffer,
-                               uint32_t                                 counterBufferCount,
-                               const VULKAN_HPP_NAMESPACE::Buffer *     pCounterBuffers,
-                               const VULKAN_HPP_NAMESPACE::DeviceSize * pCounterBufferOffsets,
-                               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 endTransformFeedbackEXT( uint32_t                                               firstCounterBuffer,
-                                  ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & counterBuffers,
-                                  ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets
-                                                     VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
-      VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#if defined( VK_ENABLE_BETA_EXTENSIONS )
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void endVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR * pEndCodingInfo,
-                            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 endVideoCodingKHR( const VideoEndCodingInfoKHR & endCodingInfo,
-                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_ENABLE_BETA_EXTENSIONS*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void executeCommands( uint32_t                                    commandBufferCount,
-                          const VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers,
-                          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 executeCommands( ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers,
-                          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 executeGeneratedCommandsNV( VULKAN_HPP_NAMESPACE::Bool32                          isPreprocessed,
-                                     const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV * pGeneratedCommandsInfo,
-                                     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 executeGeneratedCommandsNV( VULKAN_HPP_NAMESPACE::Bool32    isPreprocessed,
-                                     const GeneratedCommandsInfoNV & generatedCommandsInfo,
-                                     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 fillBuffer( VULKAN_HPP_NAMESPACE::Buffer     dstBuffer,
-                     VULKAN_HPP_NAMESPACE::DeviceSize dstOffset,
-                     VULKAN_HPP_NAMESPACE::DeviceSize size,
-                     uint32_t                         data,
-                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void
-      insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo,
-                                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
-      insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo,
-                                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 nextSubpass( VULKAN_HPP_NAMESPACE::SubpassContents contents,
-                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void nextSubpass2( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo * pSubpassBeginInfo,
-                       const VULKAN_HPP_NAMESPACE::SubpassEndInfo *   pSubpassEndInfo,
-                       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 nextSubpass2( const SubpassBeginInfo & subpassBeginInfo,
-                       const SubpassEndInfo &   subpassEndInfo,
-                       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 nextSubpass2KHR( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo * pSubpassBeginInfo,
-                          const VULKAN_HPP_NAMESPACE::SubpassEndInfo *   pSubpassEndInfo,
-                          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 nextSubpass2KHR( const SubpassBeginInfo & subpassBeginInfo,
-                          const SubpassEndInfo &   subpassEndInfo,
-                          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 pipelineBarrier( VULKAN_HPP_NAMESPACE::PipelineStageFlags          srcStageMask,
-                          VULKAN_HPP_NAMESPACE::PipelineStageFlags          dstStageMask,
-                          VULKAN_HPP_NAMESPACE::DependencyFlags             dependencyFlags,
-                          uint32_t                                          memoryBarrierCount,
-                          const VULKAN_HPP_NAMESPACE::MemoryBarrier *       pMemoryBarriers,
-                          uint32_t                                          bufferMemoryBarrierCount,
-                          const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier * pBufferMemoryBarriers,
-                          uint32_t                                          imageMemoryBarrierCount,
-                          const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier *  pImageMemoryBarriers,
-                          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 pipelineBarrier( VULKAN_HPP_NAMESPACE::PipelineStageFlags                            srcStageMask,
-                          VULKAN_HPP_NAMESPACE::PipelineStageFlags                            dstStageMask,
-                          VULKAN_HPP_NAMESPACE::DependencyFlags                               dependencyFlags,
-                          ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const &       memoryBarriers,
-                          ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const & bufferMemoryBarriers,
-                          ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const &  imageMemoryBarriers,
-                          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 pipelineBarrier2KHR( const VULKAN_HPP_NAMESPACE::DependencyInfoKHR * pDependencyInfo,
-                              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 pipelineBarrier2KHR( const DependencyInfoKHR & dependencyInfo,
-                              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 preprocessGeneratedCommandsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV * pGeneratedCommandsInfo,
-                                        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 preprocessGeneratedCommandsNV( const GeneratedCommandsInfoNV & generatedCommandsInfo,
-                                        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 pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout   layout,
-                        VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags,
-                        uint32_t                               offset,
-                        uint32_t                               size,
-                        const void *                           pValues,
-                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout   layout,
-                        VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags,
-                        uint32_t                               offset,
-                        ArrayProxy<const T> const &            values,
-                        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 pushDescriptorSetKHR( VULKAN_HPP_NAMESPACE::PipelineBindPoint          pipelineBindPoint,
-                               VULKAN_HPP_NAMESPACE::PipelineLayout             layout,
-                               uint32_t                                         set,
-                               uint32_t                                         descriptorWriteCount,
-                               const VULKAN_HPP_NAMESPACE::WriteDescriptorSet * pDescriptorWrites,
-                               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 pushDescriptorSetKHR( VULKAN_HPP_NAMESPACE::PipelineBindPoint                            pipelineBindPoint,
-                               VULKAN_HPP_NAMESPACE::PipelineLayout                               layout,
-                               uint32_t                                                           set,
-                               ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites,
-                               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 pushDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
-                                           VULKAN_HPP_NAMESPACE::PipelineLayout           layout,
-                                           uint32_t                                       set,
-                                           const void *                                   pData,
-                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
-      VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void resetEvent( VULKAN_HPP_NAMESPACE::Event              event,
-                     VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask,
-                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void resetEvent2KHR( VULKAN_HPP_NAMESPACE::Event                  event,
-                         VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR stageMask,
-                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void resetQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
-                         uint32_t                        firstQuery,
-                         uint32_t                        queryCount,
-                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     void resolveImage( VULKAN_HPP_NAMESPACE::Image                srcImage,
                        VULKAN_HPP_NAMESPACE::ImageLayout          srcImageLayout,
@@ -38448,424 +37799,15 @@ 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 resolveImage2KHR( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2KHR * pResolveImageInfo,
-                           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 resolveImage2KHR( const ResolveImageInfo2KHR & resolveImageInfo,
-                           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 setBlendConstants( const float        blendConstants[4],
-                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void setCheckpointNV( const void *       pCheckpointMarker,
-                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void
-      setCoarseSampleOrderNV( VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV           sampleOrderType,
-                              uint32_t                                                customSampleOrderCount,
-                              const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV * pCustomSampleOrders,
-                              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 setCoarseSampleOrderNV(
-      VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV                             sampleOrderType,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV> const & customSampleOrders,
-      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
-      setColorWriteEnableEXT( uint32_t                             attachmentCount,
-                              const VULKAN_HPP_NAMESPACE::Bool32 * pColorWriteEnables,
-                              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
-      setColorWriteEnableEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & colorWriteEnables,
-                              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 setCullModeEXT( VULKAN_HPP_NAMESPACE::CullModeFlags cullMode,
-                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void setDepthBias( float              depthBiasConstantFactor,
-                       float              depthBiasClamp,
-                       float              depthBiasSlopeFactor,
-                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void setDepthBiasEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable,
-                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void setDepthBounds( float              minDepthBounds,
-                         float              maxDepthBounds,
-                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void setDepthBoundsTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable,
-                                      Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
-      VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void setDepthCompareOpEXT( VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp,
-                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void setDepthTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable,
-                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void
-      setDepthWriteEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable,
-                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void setDeviceMask( uint32_t           deviceMask,
-                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void setDeviceMaskKHR( uint32_t           deviceMask,
-                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void
-      setDiscardRectangleEXT( uint32_t                             firstDiscardRectangle,
-                              uint32_t                             discardRectangleCount,
-                              const VULKAN_HPP_NAMESPACE::Rect2D * pDiscardRectangles,
-                              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
-      setDiscardRectangleEXT( uint32_t                                               firstDiscardRectangle,
-                              ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & discardRectangles,
-                              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 setEvent( VULKAN_HPP_NAMESPACE::Event              event,
                    VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask,
                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void setEvent2KHR( VULKAN_HPP_NAMESPACE::Event                     event,
-                       const VULKAN_HPP_NAMESPACE::DependencyInfoKHR * pDependencyInfo,
-                       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 setEvent2KHR( VULKAN_HPP_NAMESPACE::Event event,
-                       const DependencyInfoKHR &   dependencyInfo,
-                       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 setExclusiveScissorNV( uint32_t                             firstExclusiveScissor,
-                                uint32_t                             exclusiveScissorCount,
-                                const VULKAN_HPP_NAMESPACE::Rect2D * pExclusiveScissors,
-                                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 setExclusiveScissorNV( uint32_t                                               firstExclusiveScissor,
-                                ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & exclusiveScissors,
-                                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 setFragmentShadingRateEnumNV( VULKAN_HPP_NAMESPACE::FragmentShadingRateNV                  shadingRate,
-                                       const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2],
-                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
-      VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void setFragmentShadingRateKHR( const VULKAN_HPP_NAMESPACE::Extent2D *                       pFragmentSize,
-                                    const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2],
-                                    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 setFragmentShadingRateKHR( const Extent2D &                                             fragmentSize,
-                                    const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2],
-                                    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 setFrontFaceEXT( VULKAN_HPP_NAMESPACE::FrontFace frontFace,
-                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void setLineStippleEXT( uint32_t           lineStippleFactor,
-                            uint16_t           lineStipplePattern,
-                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void setLineWidth( float              lineWidth,
-                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void setLogicOpEXT( VULKAN_HPP_NAMESPACE::LogicOp logicOp,
-                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void
-      setPatchControlPointsEXT( uint32_t           patchControlPoints,
-                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result setPerformanceMarkerINTEL(
-      const VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL * pMarkerInfo,
-      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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
-      setPerformanceMarkerINTEL( const PerformanceMarkerInfoINTEL & markerInfo,
-                                 Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result setPerformanceOverrideINTEL(
-      const VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL * pOverrideInfo,
-      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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
-      setPerformanceOverrideINTEL( const PerformanceOverrideInfoINTEL & overrideInfo,
-                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result setPerformanceStreamMarkerINTEL(
-      const VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL * pMarkerInfo,
-      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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
-      setPerformanceStreamMarkerINTEL( const PerformanceStreamMarkerInfoINTEL & markerInfo,
-                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void setPrimitiveRestartEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable,
-                                       Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
-      VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void
-      setPrimitiveTopologyEXT( VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology,
-                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void setRasterizerDiscardEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable,
-                                        Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
-      VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void setRayTracingPipelineStackSizeKHR( uint32_t           pipelineStackSize,
-                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
-      VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void setSampleLocationsEXT( const VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT * pSampleLocationsInfo,
-                                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 setSampleLocationsEXT( const SampleLocationsInfoEXT & sampleLocationsInfo,
-                                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 setScissor( uint32_t                             firstScissor,
-                     uint32_t                             scissorCount,
-                     const VULKAN_HPP_NAMESPACE::Rect2D * pScissors,
+    void resetEvent( VULKAN_HPP_NAMESPACE::Event              event,
+                     VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask,
                      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 setScissor( uint32_t                                               firstScissor,
-                     ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors,
-                     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
-      setScissorWithCountEXT( uint32_t                             scissorCount,
-                              const VULKAN_HPP_NAMESPACE::Rect2D * pScissors,
-                              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
-      setScissorWithCountEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors,
-                              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 setStencilCompareMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
-                                uint32_t                               compareMask,
-                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void setStencilOpEXT( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
-                          VULKAN_HPP_NAMESPACE::StencilOp        failOp,
-                          VULKAN_HPP_NAMESPACE::StencilOp        passOp,
-                          VULKAN_HPP_NAMESPACE::StencilOp        depthFailOp,
-                          VULKAN_HPP_NAMESPACE::CompareOp        compareOp,
-                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void setStencilReference( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
-                              uint32_t                               reference,
-                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void
-      setStencilTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable,
-                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void setStencilWriteMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
-                              uint32_t                               writeMask,
-                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void
-      setVertexInputEXT( uint32_t                                                        vertexBindingDescriptionCount,
-                         const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT * pVertexBindingDescriptions,
-                         uint32_t vertexAttributeDescriptionCount,
-                         const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT * pVertexAttributeDescriptions,
-                         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 setVertexInputEXT(
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT> const &   vertexBindingDescriptions,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT> const & vertexAttributeDescriptions,
-      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 setViewport( uint32_t                               firstViewport,
-                      uint32_t                               viewportCount,
-                      const VULKAN_HPP_NAMESPACE::Viewport * pViewports,
-                      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 setViewport( uint32_t                                                 firstViewport,
-                      ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports,
-                      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 setViewportShadingRatePaletteNV( uint32_t                                           firstViewport,
-                                          uint32_t                                           viewportCount,
-                                          const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV * pShadingRatePalettes,
-                                          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 setViewportShadingRatePaletteNV(
-      uint32_t                                                             firstViewport,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV> const & shadingRatePalettes,
-      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 setViewportWScalingNV( uint32_t                                         firstViewport,
-                                uint32_t                                         viewportCount,
-                                const VULKAN_HPP_NAMESPACE::ViewportWScalingNV * pViewportWScalings,
-                                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 setViewportWScalingNV( uint32_t                                                           firstViewport,
-                                ArrayProxy<const VULKAN_HPP_NAMESPACE::ViewportWScalingNV> const & viewportWScalings,
-                                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
-      setViewportWithCountEXT( uint32_t                               viewportCount,
-                               const VULKAN_HPP_NAMESPACE::Viewport * pViewports,
-                               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
-      setViewportWithCountEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports,
-                               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 traceRaysIndirectKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pRaygenShaderBindingTable,
-                               const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pMissShaderBindingTable,
-                               const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pHitShaderBindingTable,
-                               const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pCallableShaderBindingTable,
-                               VULKAN_HPP_NAMESPACE::DeviceAddress                         indirectDeviceAddress,
-                               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 traceRaysIndirectKHR( const StridedDeviceAddressRegionKHR & raygenShaderBindingTable,
-                               const StridedDeviceAddressRegionKHR & missShaderBindingTable,
-                               const StridedDeviceAddressRegionKHR & hitShaderBindingTable,
-                               const StridedDeviceAddressRegionKHR & callableShaderBindingTable,
-                               VULKAN_HPP_NAMESPACE::DeviceAddress   indirectDeviceAddress,
-                               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 traceRaysKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pRaygenShaderBindingTable,
-                       const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pMissShaderBindingTable,
-                       const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pHitShaderBindingTable,
-                       const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pCallableShaderBindingTable,
-                       uint32_t                                                    width,
-                       uint32_t                                                    height,
-                       uint32_t                                                    depth,
-                       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 traceRaysKHR( const StridedDeviceAddressRegionKHR & raygenShaderBindingTable,
-                       const StridedDeviceAddressRegionKHR & missShaderBindingTable,
-                       const StridedDeviceAddressRegionKHR & hitShaderBindingTable,
-                       const StridedDeviceAddressRegionKHR & callableShaderBindingTable,
-                       uint32_t                              width,
-                       uint32_t                              height,
-                       uint32_t                              depth,
-                       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 traceRaysNV( VULKAN_HPP_NAMESPACE::Buffer     raygenShaderBindingTableBuffer,
-                      VULKAN_HPP_NAMESPACE::DeviceSize raygenShaderBindingOffset,
-                      VULKAN_HPP_NAMESPACE::Buffer     missShaderBindingTableBuffer,
-                      VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingOffset,
-                      VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingStride,
-                      VULKAN_HPP_NAMESPACE::Buffer     hitShaderBindingTableBuffer,
-                      VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingOffset,
-                      VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingStride,
-                      VULKAN_HPP_NAMESPACE::Buffer     callableShaderBindingTableBuffer,
-                      VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingOffset,
-                      VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingStride,
-                      uint32_t                         width,
-                      uint32_t                         height,
-                      uint32_t                         depth,
-                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void updateBuffer( VULKAN_HPP_NAMESPACE::Buffer     dstBuffer,
-                       VULKAN_HPP_NAMESPACE::DeviceSize dstOffset,
-                       VULKAN_HPP_NAMESPACE::DeviceSize dataSize,
-                       const void *                     pData,
-                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void updateBuffer( VULKAN_HPP_NAMESPACE::Buffer     dstBuffer,
-                       VULKAN_HPP_NAMESPACE::DeviceSize dstOffset,
-                       ArrayProxy<const T> const &      data,
-                       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 waitEvents( uint32_t                                          eventCount,
@@ -38891,18 +37833,573 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void waitEvents2KHR( uint32_t                                        eventCount,
-                         const VULKAN_HPP_NAMESPACE::Event *             pEvents,
-                         const VULKAN_HPP_NAMESPACE::DependencyInfoKHR * pDependencyInfos,
+    void pipelineBarrier( VULKAN_HPP_NAMESPACE::PipelineStageFlags          srcStageMask,
+                          VULKAN_HPP_NAMESPACE::PipelineStageFlags          dstStageMask,
+                          VULKAN_HPP_NAMESPACE::DependencyFlags             dependencyFlags,
+                          uint32_t                                          memoryBarrierCount,
+                          const VULKAN_HPP_NAMESPACE::MemoryBarrier *       pMemoryBarriers,
+                          uint32_t                                          bufferMemoryBarrierCount,
+                          const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier * pBufferMemoryBarriers,
+                          uint32_t                                          imageMemoryBarrierCount,
+                          const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier *  pImageMemoryBarriers,
+                          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 pipelineBarrier( VULKAN_HPP_NAMESPACE::PipelineStageFlags                            srcStageMask,
+                          VULKAN_HPP_NAMESPACE::PipelineStageFlags                            dstStageMask,
+                          VULKAN_HPP_NAMESPACE::DependencyFlags                               dependencyFlags,
+                          ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const &       memoryBarriers,
+                          ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const & bufferMemoryBarriers,
+                          ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const &  imageMemoryBarriers,
+                          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 beginQuery( VULKAN_HPP_NAMESPACE::QueryPool         queryPool,
+                     uint32_t                                query,
+                     VULKAN_HPP_NAMESPACE::QueryControlFlags flags,
+                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void endQuery( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
+                   uint32_t                        query,
+                   Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void resetQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
+                         uint32_t                        firstQuery,
+                         uint32_t                        queryCount,
+                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void writeTimestamp( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage,
+                         VULKAN_HPP_NAMESPACE::QueryPool             queryPool,
+                         uint32_t                                    query,
+                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void copyQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool        queryPool,
+                               uint32_t                               firstQuery,
+                               uint32_t                               queryCount,
+                               VULKAN_HPP_NAMESPACE::Buffer           dstBuffer,
+                               VULKAN_HPP_NAMESPACE::DeviceSize       dstOffset,
+                               VULKAN_HPP_NAMESPACE::DeviceSize       stride,
+                               VULKAN_HPP_NAMESPACE::QueryResultFlags flags,
+                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout   layout,
+                        VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags,
+                        uint32_t                               offset,
+                        uint32_t                               size,
+                        const void *                           pValues,
+                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout   layout,
+                        VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags,
+                        uint32_t                               offset,
+                        ArrayProxy<const T> const &            values,
+                        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 beginRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo * pRenderPassBegin,
+                          VULKAN_HPP_NAMESPACE::SubpassContents             contents,
+                          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 beginRenderPass( const RenderPassBeginInfo &           renderPassBegin,
+                          VULKAN_HPP_NAMESPACE::SubpassContents contents,
+                          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 nextSubpass( VULKAN_HPP_NAMESPACE::SubpassContents contents,
+                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void endRenderPass( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void executeCommands( uint32_t                                    commandBufferCount,
+                          const VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers,
+                          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 executeCommands( ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers,
+                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    //=== VK_VERSION_1_1 ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void setDeviceMask( uint32_t           deviceMask,
+                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void dispatchBase( uint32_t           baseGroupX,
+                       uint32_t           baseGroupY,
+                       uint32_t           baseGroupZ,
+                       uint32_t           groupCountX,
+                       uint32_t           groupCountY,
+                       uint32_t           groupCountZ,
+                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+    //=== VK_VERSION_1_2 ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void drawIndirectCount( VULKAN_HPP_NAMESPACE::Buffer     buffer,
+                            VULKAN_HPP_NAMESPACE::DeviceSize offset,
+                            VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
+                            VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
+                            uint32_t                         maxDrawCount,
+                            uint32_t                         stride,
+                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void
+      drawIndexedIndirectCount( VULKAN_HPP_NAMESPACE::Buffer     buffer,
+                                VULKAN_HPP_NAMESPACE::DeviceSize offset,
+                                VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
+                                VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
+                                uint32_t                         maxDrawCount,
+                                uint32_t                         stride,
+                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void beginRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo * pRenderPassBegin,
+                           const VULKAN_HPP_NAMESPACE::SubpassBeginInfo *    pSubpassBeginInfo,
+                           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 beginRenderPass2( const RenderPassBeginInfo & renderPassBegin,
+                           const SubpassBeginInfo &    subpassBeginInfo,
+                           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 nextSubpass2( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo * pSubpassBeginInfo,
+                       const VULKAN_HPP_NAMESPACE::SubpassEndInfo *   pSubpassEndInfo,
+                       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 nextSubpass2( const SubpassBeginInfo & subpassBeginInfo,
+                       const SubpassEndInfo &   subpassEndInfo,
+                       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 endRenderPass2( const VULKAN_HPP_NAMESPACE::SubpassEndInfo * pSubpassEndInfo,
                          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 waitEvents2KHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const &             events,
-                         ArrayProxy<const VULKAN_HPP_NAMESPACE::DependencyInfoKHR> const & dependencyInfos,
-                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
+    void endRenderPass2( const SubpassEndInfo & subpassEndInfo,
+                         Dispatch const & d     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    //=== VK_EXT_debug_marker ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void debugMarkerBeginEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT * pMarkerInfo,
+                              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 debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT & markerInfo,
+                              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 debugMarkerEndEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void debugMarkerInsertEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT * pMarkerInfo,
+                               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 debugMarkerInsertEXT( const DebugMarkerMarkerInfoEXT & markerInfo,
+                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#if defined( VK_ENABLE_BETA_EXTENSIONS )
+    //=== VK_KHR_video_queue ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void beginVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR * pBeginInfo,
+                              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 beginVideoCodingKHR( const VideoBeginCodingInfoKHR & beginInfo,
+                              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 endVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR * pEndCodingInfo,
+                            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 endVideoCodingKHR( const VideoEndCodingInfoKHR & endCodingInfo,
+                            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 controlVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR * pCodingControlInfo,
+                                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 controlVideoCodingKHR( const VideoCodingControlInfoKHR & codingControlInfo,
+                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VK_ENABLE_BETA_EXTENSIONS*/
+
+#if defined( VK_ENABLE_BETA_EXTENSIONS )
+    //=== VK_KHR_video_decode_queue ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void decodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR * pFrameInfo,
+                         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 decodeVideoKHR( const VideoDecodeInfoKHR & frameInfo,
+                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VK_ENABLE_BETA_EXTENSIONS*/
+
+    //=== VK_EXT_transform_feedback ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void bindTransformFeedbackBuffersEXT( uint32_t                                 firstBinding,
+                                          uint32_t                                 bindingCount,
+                                          const VULKAN_HPP_NAMESPACE::Buffer *     pBuffers,
+                                          const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets,
+                                          const VULKAN_HPP_NAMESPACE::DeviceSize * pSizes,
+                                          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 bindTransformFeedbackBuffersEXT(
+      uint32_t                                                         firstBinding,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &           buffers,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const &       offsets,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void beginTransformFeedbackEXT( uint32_t                                 firstCounterBuffer,
+                                    uint32_t                                 counterBufferCount,
+                                    const VULKAN_HPP_NAMESPACE::Buffer *     pCounterBuffers,
+                                    const VULKAN_HPP_NAMESPACE::DeviceSize * pCounterBufferOffsets,
+                                    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 beginTransformFeedbackEXT( uint32_t                                               firstCounterBuffer,
+                                    ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & counterBuffers,
+                                    ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets
+                                                       VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
       VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void
+      endTransformFeedbackEXT( uint32_t                                 firstCounterBuffer,
+                               uint32_t                                 counterBufferCount,
+                               const VULKAN_HPP_NAMESPACE::Buffer *     pCounterBuffers,
+                               const VULKAN_HPP_NAMESPACE::DeviceSize * pCounterBufferOffsets,
+                               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 endTransformFeedbackEXT( uint32_t                                               firstCounterBuffer,
+                                  ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & counterBuffers,
+                                  ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets
+                                                     VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
+      VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void beginQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool         queryPool,
+                               uint32_t                                query,
+                               VULKAN_HPP_NAMESPACE::QueryControlFlags flags,
+                               uint32_t                                index,
+                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void endQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
+                             uint32_t                        query,
+                             uint32_t                        index,
+                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void
+      drawIndirectByteCountEXT( uint32_t                         instanceCount,
+                                uint32_t                         firstInstance,
+                                VULKAN_HPP_NAMESPACE::Buffer     counterBuffer,
+                                VULKAN_HPP_NAMESPACE::DeviceSize counterBufferOffset,
+                                uint32_t                         counterOffset,
+                                uint32_t                         vertexStride,
+                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+    //=== VK_NVX_binary_import ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void cuLaunchKernelNVX( const VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX * pLaunchInfo,
+                            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 cuLaunchKernelNVX( const CuLaunchInfoNVX & launchInfo,
+                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    //=== VK_AMD_draw_indirect_count ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void drawIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer     buffer,
+                               VULKAN_HPP_NAMESPACE::DeviceSize offset,
+                               VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
+                               VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
+                               uint32_t                         maxDrawCount,
+                               uint32_t                         stride,
+                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void drawIndexedIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer     buffer,
+                                      VULKAN_HPP_NAMESPACE::DeviceSize offset,
+                                      VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
+                                      VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
+                                      uint32_t                         maxDrawCount,
+                                      uint32_t                         stride,
+                                      Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
+      VULKAN_HPP_NOEXCEPT;
+
+    //=== VK_KHR_device_group ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void setDeviceMaskKHR( uint32_t           deviceMask,
+                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void dispatchBaseKHR( uint32_t           baseGroupX,
+                          uint32_t           baseGroupY,
+                          uint32_t           baseGroupZ,
+                          uint32_t           groupCountX,
+                          uint32_t           groupCountY,
+                          uint32_t           groupCountZ,
+                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+    //=== VK_KHR_push_descriptor ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void pushDescriptorSetKHR( VULKAN_HPP_NAMESPACE::PipelineBindPoint          pipelineBindPoint,
+                               VULKAN_HPP_NAMESPACE::PipelineLayout             layout,
+                               uint32_t                                         set,
+                               uint32_t                                         descriptorWriteCount,
+                               const VULKAN_HPP_NAMESPACE::WriteDescriptorSet * pDescriptorWrites,
+                               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 pushDescriptorSetKHR( VULKAN_HPP_NAMESPACE::PipelineBindPoint                            pipelineBindPoint,
+                               VULKAN_HPP_NAMESPACE::PipelineLayout                               layout,
+                               uint32_t                                                           set,
+                               ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites,
+                               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 pushDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
+                                           VULKAN_HPP_NAMESPACE::PipelineLayout           layout,
+                                           uint32_t                                       set,
+                                           const void *                                   pData,
+                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
+      VULKAN_HPP_NOEXCEPT;
+
+    //=== VK_EXT_conditional_rendering ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void beginConditionalRenderingEXT(
+      const VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT * pConditionalRenderingBegin,
+      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 beginConditionalRenderingEXT( const ConditionalRenderingBeginInfoEXT & conditionalRenderingBegin,
+                                       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 endConditionalRenderingEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
+      VULKAN_HPP_NOEXCEPT;
+
+    //=== VK_NV_clip_space_w_scaling ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void setViewportWScalingNV( uint32_t                                         firstViewport,
+                                uint32_t                                         viewportCount,
+                                const VULKAN_HPP_NAMESPACE::ViewportWScalingNV * pViewportWScalings,
+                                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 setViewportWScalingNV( uint32_t                                                           firstViewport,
+                                ArrayProxy<const VULKAN_HPP_NAMESPACE::ViewportWScalingNV> const & viewportWScalings,
+                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    //=== VK_EXT_discard_rectangles ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void
+      setDiscardRectangleEXT( uint32_t                             firstDiscardRectangle,
+                              uint32_t                             discardRectangleCount,
+                              const VULKAN_HPP_NAMESPACE::Rect2D * pDiscardRectangles,
+                              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
+      setDiscardRectangleEXT( uint32_t                                               firstDiscardRectangle,
+                              ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & discardRectangles,
+                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    //=== VK_KHR_create_renderpass2 ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void beginRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo * pRenderPassBegin,
+                              const VULKAN_HPP_NAMESPACE::SubpassBeginInfo *    pSubpassBeginInfo,
+                              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 beginRenderPass2KHR( const RenderPassBeginInfo & renderPassBegin,
+                              const SubpassBeginInfo &    subpassBeginInfo,
+                              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 nextSubpass2KHR( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo * pSubpassBeginInfo,
+                          const VULKAN_HPP_NAMESPACE::SubpassEndInfo *   pSubpassEndInfo,
+                          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 nextSubpass2KHR( const SubpassBeginInfo & subpassBeginInfo,
+                          const SubpassEndInfo &   subpassEndInfo,
+                          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 endRenderPass2KHR( const VULKAN_HPP_NAMESPACE::SubpassEndInfo * pSubpassEndInfo,
+                            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 endRenderPass2KHR( const SubpassEndInfo & subpassEndInfo,
+                            Dispatch const & d     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    //=== VK_EXT_debug_utils ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void
+      beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo,
+                               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
+      beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo,
+                               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 endDebugUtilsLabelEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void
+      insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo,
+                                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
+      insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo,
+                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    //=== VK_EXT_sample_locations ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void setSampleLocationsEXT( const VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT * pSampleLocationsInfo,
+                                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 setSampleLocationsEXT( const SampleLocationsInfoEXT & sampleLocationsInfo,
+                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    //=== VK_KHR_acceleration_structure ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void buildAccelerationStructuresKHR(
+      uint32_t                                                                     infoCount,
+      const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR *      pInfos,
+      const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos,
+      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 buildAccelerationStructuresKHR(
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const &      infos,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos,
+      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void buildAccelerationStructuresIndirectKHR(
+      uint32_t                                                                infoCount,
+      const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR * pInfos,
+      const VULKAN_HPP_NAMESPACE::DeviceAddress *                             pIndirectDeviceAddresses,
+      const uint32_t *                                                        pIndirectStrides,
+      const uint32_t * const *                                                ppMaxPrimitiveCounts,
+      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 buildAccelerationStructuresIndirectKHR(
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceAddress> const &                             indirectDeviceAddresses,
+      ArrayProxy<const uint32_t> const &                                                        indirectStrides,
+      ArrayProxy<const uint32_t * const> const &                                                pMaxPrimitiveCounts,
+      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void copyAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR * pInfo,
+                                       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 copyAccelerationStructureKHR( const CopyAccelerationStructureInfoKHR & info,
+                                       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 copyAccelerationStructureToMemoryKHR(
+      const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR * pInfo,
+      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 copyAccelerationStructureToMemoryKHR( const CopyAccelerationStructureToMemoryInfoKHR & info,
+                                               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 copyMemoryToAccelerationStructureKHR(
+      const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR * pInfo,
+      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 copyMemoryToAccelerationStructureKHR( const CopyMemoryToAccelerationStructureInfoKHR & info,
+                                               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 writeAccelerationStructuresPropertiesKHR(
       uint32_t                                               accelerationStructureCount,
@@ -38921,6 +38418,93 @@ namespace VULKAN_HPP_NAMESPACE
       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+    //=== VK_NV_shading_rate_image ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void
+      bindShadingRateImageNV( VULKAN_HPP_NAMESPACE::ImageView   imageView,
+                              VULKAN_HPP_NAMESPACE::ImageLayout imageLayout,
+                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void setViewportShadingRatePaletteNV( uint32_t                                           firstViewport,
+                                          uint32_t                                           viewportCount,
+                                          const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV * pShadingRatePalettes,
+                                          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 setViewportShadingRatePaletteNV(
+      uint32_t                                                             firstViewport,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV> const & shadingRatePalettes,
+      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
+      setCoarseSampleOrderNV( VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV           sampleOrderType,
+                              uint32_t                                                customSampleOrderCount,
+                              const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV * pCustomSampleOrders,
+                              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 setCoarseSampleOrderNV(
+      VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV                             sampleOrderType,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV> const & customSampleOrders,
+      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    //=== VK_NV_ray_tracing ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void buildAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV * pInfo,
+                                       VULKAN_HPP_NAMESPACE::Buffer                              instanceData,
+                                       VULKAN_HPP_NAMESPACE::DeviceSize                          instanceOffset,
+                                       VULKAN_HPP_NAMESPACE::Bool32                              update,
+                                       VULKAN_HPP_NAMESPACE::AccelerationStructureNV             dst,
+                                       VULKAN_HPP_NAMESPACE::AccelerationStructureNV             src,
+                                       VULKAN_HPP_NAMESPACE::Buffer                              scratch,
+                                       VULKAN_HPP_NAMESPACE::DeviceSize                          scratchOffset,
+                                       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 buildAccelerationStructureNV( const AccelerationStructureInfoNV &           info,
+                                       VULKAN_HPP_NAMESPACE::Buffer                  instanceData,
+                                       VULKAN_HPP_NAMESPACE::DeviceSize              instanceOffset,
+                                       VULKAN_HPP_NAMESPACE::Bool32                  update,
+                                       VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst,
+                                       VULKAN_HPP_NAMESPACE::AccelerationStructureNV src,
+                                       VULKAN_HPP_NAMESPACE::Buffer                  scratch,
+                                       VULKAN_HPP_NAMESPACE::DeviceSize              scratchOffset,
+                                       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 copyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV          dst,
+                                      VULKAN_HPP_NAMESPACE::AccelerationStructureNV          src,
+                                      VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR mode,
+                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
+      VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void traceRaysNV( VULKAN_HPP_NAMESPACE::Buffer     raygenShaderBindingTableBuffer,
+                      VULKAN_HPP_NAMESPACE::DeviceSize raygenShaderBindingOffset,
+                      VULKAN_HPP_NAMESPACE::Buffer     missShaderBindingTableBuffer,
+                      VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingOffset,
+                      VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingStride,
+                      VULKAN_HPP_NAMESPACE::Buffer     hitShaderBindingTableBuffer,
+                      VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingOffset,
+                      VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingStride,
+                      VULKAN_HPP_NAMESPACE::Buffer     callableShaderBindingTableBuffer,
+                      VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingOffset,
+                      VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingStride,
+                      uint32_t                         width,
+                      uint32_t                         height,
+                      uint32_t                         depth,
+                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     void writeAccelerationStructuresPropertiesNV(
       uint32_t                                              accelerationStructureCount,
@@ -38939,12 +38523,28 @@ namespace VULKAN_HPP_NAMESPACE
       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+    //=== VK_KHR_draw_indirect_count ===
+
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void writeBufferMarker2AMD( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR stage,
-                                VULKAN_HPP_NAMESPACE::Buffer                 dstBuffer,
-                                VULKAN_HPP_NAMESPACE::DeviceSize             dstOffset,
-                                uint32_t                                     marker,
-                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+    void drawIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer     buffer,
+                               VULKAN_HPP_NAMESPACE::DeviceSize offset,
+                               VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
+                               VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
+                               uint32_t                         maxDrawCount,
+                               uint32_t                         stride,
+                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void drawIndexedIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer     buffer,
+                                      VULKAN_HPP_NAMESPACE::DeviceSize offset,
+                                      VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
+                                      VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
+                                      uint32_t                         maxDrawCount,
+                                      uint32_t                         stride,
+                                      Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
+      VULKAN_HPP_NOEXCEPT;
+
+    //=== VK_AMD_buffer_marker ===
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     void writeBufferMarkerAMD( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage,
@@ -38953,38 +38553,459 @@ namespace VULKAN_HPP_NAMESPACE
                                uint32_t                                    marker,
                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 
+    //=== VK_NV_mesh_shader ===
+
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void writeTimestamp( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage,
-                         VULKAN_HPP_NAMESPACE::QueryPool             queryPool,
-                         uint32_t                                    query,
+    void drawMeshTasksNV( uint32_t           taskCount,
+                          uint32_t           firstTask,
+                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void
+      drawMeshTasksIndirectNV( VULKAN_HPP_NAMESPACE::Buffer     buffer,
+                               VULKAN_HPP_NAMESPACE::DeviceSize offset,
+                               uint32_t                         drawCount,
+                               uint32_t                         stride,
+                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void drawMeshTasksIndirectCountNV( VULKAN_HPP_NAMESPACE::Buffer     buffer,
+                                       VULKAN_HPP_NAMESPACE::DeviceSize offset,
+                                       VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
+                                       VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
+                                       uint32_t                         maxDrawCount,
+                                       uint32_t                         stride,
+                                       Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
+      VULKAN_HPP_NOEXCEPT;
+
+    //=== VK_NV_scissor_exclusive ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void setExclusiveScissorNV( uint32_t                             firstExclusiveScissor,
+                                uint32_t                             exclusiveScissorCount,
+                                const VULKAN_HPP_NAMESPACE::Rect2D * pExclusiveScissors,
+                                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 setExclusiveScissorNV( uint32_t                                               firstExclusiveScissor,
+                                ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & exclusiveScissors,
+                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    //=== VK_NV_device_diagnostic_checkpoints ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void setCheckpointNV( const void *       pCheckpointMarker,
+                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+    //=== VK_INTEL_performance_query ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result setPerformanceMarkerINTEL(
+      const VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL * pMarkerInfo,
+      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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
+      setPerformanceMarkerINTEL( const PerformanceMarkerInfoINTEL & markerInfo,
+                                 Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result setPerformanceStreamMarkerINTEL(
+      const VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL * pMarkerInfo,
+      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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
+      setPerformanceStreamMarkerINTEL( const PerformanceStreamMarkerInfoINTEL & markerInfo,
+                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result setPerformanceOverrideINTEL(
+      const VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL * pOverrideInfo,
+      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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
+      setPerformanceOverrideINTEL( const PerformanceOverrideInfoINTEL & overrideInfo,
+                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    //=== VK_KHR_fragment_shading_rate ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void setFragmentShadingRateKHR( const VULKAN_HPP_NAMESPACE::Extent2D *                       pFragmentSize,
+                                    const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2],
+                                    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 setFragmentShadingRateKHR( const Extent2D &                                             fragmentSize,
+                                    const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2],
+                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
+      VULKAN_HPP_NOEXCEPT;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    //=== VK_EXT_line_rasterization ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void setLineStippleEXT( uint32_t           lineStippleFactor,
+                            uint16_t           lineStipplePattern,
+                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+    //=== VK_EXT_extended_dynamic_state ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void setCullModeEXT( VULKAN_HPP_NAMESPACE::CullModeFlags cullMode,
                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void setFrontFaceEXT( VULKAN_HPP_NAMESPACE::FrontFace frontFace,
+                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void
+      setPrimitiveTopologyEXT( VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology,
+                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void
+      setViewportWithCountEXT( uint32_t                               viewportCount,
+                               const VULKAN_HPP_NAMESPACE::Viewport * pViewports,
+                               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
+      setViewportWithCountEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports,
+                               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
+      setScissorWithCountEXT( uint32_t                             scissorCount,
+                              const VULKAN_HPP_NAMESPACE::Rect2D * pScissors,
+                              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
+      setScissorWithCountEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors,
+                              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 bindVertexBuffers2EXT( uint32_t                                 firstBinding,
+                                uint32_t                                 bindingCount,
+                                const VULKAN_HPP_NAMESPACE::Buffer *     pBuffers,
+                                const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets,
+                                const VULKAN_HPP_NAMESPACE::DeviceSize * pSizes,
+                                const VULKAN_HPP_NAMESPACE::DeviceSize * pStrides,
+                                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 bindVertexBuffers2EXT(
+      uint32_t                                                           firstBinding,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &             buffers,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const &         offsets,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & strides VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void setDepthTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable,
+                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void
+      setDepthWriteEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable,
+                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void setDepthCompareOpEXT( VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp,
+                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void setDepthBoundsTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable,
+                                      Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
+      VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void
+      setStencilTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable,
+                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void setStencilOpEXT( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
+                          VULKAN_HPP_NAMESPACE::StencilOp        failOp,
+                          VULKAN_HPP_NAMESPACE::StencilOp        passOp,
+                          VULKAN_HPP_NAMESPACE::StencilOp        depthFailOp,
+                          VULKAN_HPP_NAMESPACE::CompareOp        compareOp,
+                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+    //=== VK_NV_device_generated_commands ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void preprocessGeneratedCommandsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV * pGeneratedCommandsInfo,
+                                        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 preprocessGeneratedCommandsNV( const GeneratedCommandsInfoNV & generatedCommandsInfo,
+                                        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 executeGeneratedCommandsNV( VULKAN_HPP_NAMESPACE::Bool32                          isPreprocessed,
+                                     const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV * pGeneratedCommandsInfo,
+                                     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 executeGeneratedCommandsNV( VULKAN_HPP_NAMESPACE::Bool32    isPreprocessed,
+                                     const GeneratedCommandsInfoNV & generatedCommandsInfo,
+                                     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 bindPipelineShaderGroupNV( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
+                                    VULKAN_HPP_NAMESPACE::Pipeline          pipeline,
+                                    uint32_t                                groupIndex,
+                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
+      VULKAN_HPP_NOEXCEPT;
+
+#if defined( VK_ENABLE_BETA_EXTENSIONS )
+    //=== VK_KHR_video_encode_queue ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void encodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR * pEncodeInfo,
+                         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 encodeVideoKHR( const VideoEncodeInfoKHR & encodeInfo,
+                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VK_ENABLE_BETA_EXTENSIONS*/
+
+    //=== VK_KHR_synchronization2 ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void setEvent2KHR( VULKAN_HPP_NAMESPACE::Event                     event,
+                       const VULKAN_HPP_NAMESPACE::DependencyInfoKHR * pDependencyInfo,
+                       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 setEvent2KHR( VULKAN_HPP_NAMESPACE::Event event,
+                       const DependencyInfoKHR &   dependencyInfo,
+                       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 resetEvent2KHR( VULKAN_HPP_NAMESPACE::Event                  event,
+                         VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR stageMask,
+                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void waitEvents2KHR( uint32_t                                        eventCount,
+                         const VULKAN_HPP_NAMESPACE::Event *             pEvents,
+                         const VULKAN_HPP_NAMESPACE::DependencyInfoKHR * pDependencyInfos,
+                         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 waitEvents2KHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const &             events,
+                         ArrayProxy<const VULKAN_HPP_NAMESPACE::DependencyInfoKHR> const & dependencyInfos,
+                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
+      VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void pipelineBarrier2KHR( const VULKAN_HPP_NAMESPACE::DependencyInfoKHR * pDependencyInfo,
+                              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 pipelineBarrier2KHR( const DependencyInfoKHR & dependencyInfo,
+                              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 writeTimestamp2KHR( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR stage,
                              VULKAN_HPP_NAMESPACE::QueryPool              queryPool,
                              uint32_t                                     query,
                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      end( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#else
+    void writeBufferMarker2AMD( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR stage,
+                                VULKAN_HPP_NAMESPACE::Buffer                 dstBuffer,
+                                VULKAN_HPP_NAMESPACE::DeviceSize             dstOffset,
+                                uint32_t                                     marker,
+                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+    //=== VK_NV_fragment_shading_rate_enums ===
+
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
-      end( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    void setFragmentShadingRateEnumNV( VULKAN_HPP_NAMESPACE::FragmentShadingRateNV                  shadingRate,
+                                       const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2],
+                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
+      VULKAN_HPP_NOEXCEPT;
+
+    //=== VK_KHR_copy_commands2 ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void copyBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2KHR * pCopyBufferInfo,
+                         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 copyBuffer2KHR( const CopyBufferInfo2KHR & copyBufferInfo,
+                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      reset( VULKAN_HPP_NAMESPACE::CommandBufferResetFlags flags,
-             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#else
+    void copyImage2KHR( const VULKAN_HPP_NAMESPACE::CopyImageInfo2KHR * pCopyImageInfo,
+                        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>
-    typename ResultValueType<void>::type
-         reset( VULKAN_HPP_NAMESPACE::CommandBufferResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
-                Dispatch const & d                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    void copyImage2KHR( const CopyImageInfo2KHR & copyImageInfo,
+                        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 copyBufferToImage2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2KHR * pCopyBufferToImageInfo,
+                                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 copyBufferToImage2KHR( const CopyBufferToImageInfo2KHR & copyBufferToImageInfo,
+                                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 copyImageToBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2KHR * pCopyImageToBufferInfo,
+                                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 copyImageToBuffer2KHR( const CopyImageToBufferInfo2KHR & copyImageToBufferInfo,
+                                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 blitImage2KHR( const VULKAN_HPP_NAMESPACE::BlitImageInfo2KHR * pBlitImageInfo,
+                        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 blitImage2KHR( const BlitImageInfo2KHR & blitImageInfo,
+                        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 resolveImage2KHR( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2KHR * pResolveImageInfo,
+                           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 resolveImage2KHR( const ResolveImageInfo2KHR & resolveImageInfo,
+                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    //=== VK_KHR_ray_tracing_pipeline ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void traceRaysKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pRaygenShaderBindingTable,
+                       const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pMissShaderBindingTable,
+                       const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pHitShaderBindingTable,
+                       const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pCallableShaderBindingTable,
+                       uint32_t                                                    width,
+                       uint32_t                                                    height,
+                       uint32_t                                                    depth,
+                       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 traceRaysKHR( const StridedDeviceAddressRegionKHR & raygenShaderBindingTable,
+                       const StridedDeviceAddressRegionKHR & missShaderBindingTable,
+                       const StridedDeviceAddressRegionKHR & hitShaderBindingTable,
+                       const StridedDeviceAddressRegionKHR & callableShaderBindingTable,
+                       uint32_t                              width,
+                       uint32_t                              height,
+                       uint32_t                              depth,
+                       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 traceRaysIndirectKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pRaygenShaderBindingTable,
+                               const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pMissShaderBindingTable,
+                               const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pHitShaderBindingTable,
+                               const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pCallableShaderBindingTable,
+                               VULKAN_HPP_NAMESPACE::DeviceAddress                         indirectDeviceAddress,
+                               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 traceRaysIndirectKHR( const StridedDeviceAddressRegionKHR & raygenShaderBindingTable,
+                               const StridedDeviceAddressRegionKHR & missShaderBindingTable,
+                               const StridedDeviceAddressRegionKHR & hitShaderBindingTable,
+                               const StridedDeviceAddressRegionKHR & callableShaderBindingTable,
+                               VULKAN_HPP_NAMESPACE::DeviceAddress   indirectDeviceAddress,
+                               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 setRayTracingPipelineStackSizeKHR( uint32_t           pipelineStackSize,
+                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
+      VULKAN_HPP_NOEXCEPT;
+
+    //=== VK_EXT_vertex_input_dynamic_state ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void
+      setVertexInputEXT( uint32_t                                                        vertexBindingDescriptionCount,
+                         const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT * pVertexBindingDescriptions,
+                         uint32_t vertexAttributeDescriptionCount,
+                         const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT * pVertexAttributeDescriptions,
+                         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 setVertexInputEXT(
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT> const &   vertexBindingDescriptions,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT> const & vertexAttributeDescriptions,
+      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    //=== VK_EXT_extended_dynamic_state2 ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void
+      setPatchControlPointsEXT( uint32_t           patchControlPoints,
+                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void setRasterizerDiscardEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable,
+                                        Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
+      VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void setDepthBiasEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable,
+                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void setLogicOpEXT( VULKAN_HPP_NAMESPACE::LogicOp logicOp,
+                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void setPrimitiveRestartEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable,
+                                       Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
+      VULKAN_HPP_NOEXCEPT;
+
+    //=== VK_EXT_color_write_enable ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void
+      setColorWriteEnableEXT( uint32_t                             attachmentCount,
+                              const VULKAN_HPP_NAMESPACE::Bool32 * pColorWriteEnables,
+                              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
+      setColorWriteEnableEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & colorWriteEnables,
+                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCommandBuffer() const VULKAN_HPP_NOEXCEPT
@@ -54117,24 +54138,87 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+    //=== VK_VERSION_1_0 ===
+
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void getCheckpointData2NV( uint32_t *                                pCheckpointDataCount,
-                               VULKAN_HPP_NAMESPACE::CheckpointData2NV * pCheckpointData,
+    VULKAN_HPP_NODISCARD Result
+      submit( uint32_t                                 submitCount,
+              const VULKAN_HPP_NAMESPACE::SubmitInfo * pSubmits,
+              VULKAN_HPP_NAMESPACE::Fence              fence,
+              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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
+      submit( ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo> const & submits,
+              VULKAN_HPP_NAMESPACE::Fence fence                          VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
+              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#else
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
+      waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      bindSparse( uint32_t                                     bindInfoCount,
+                  const VULKAN_HPP_NAMESPACE::BindSparseInfo * pBindInfo,
+                  VULKAN_HPP_NAMESPACE::Fence                  fence,
+                  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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
+      bindSparse( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindSparseInfo> const & bindInfo,
+                  VULKAN_HPP_NAMESPACE::Fence fence                              VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
+                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    //=== VK_KHR_swapchain ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      presentKHR( const VULKAN_HPP_NAMESPACE::PresentInfoKHR * pPresentInfo,
+                  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>
+    VULKAN_HPP_NODISCARD Result presentKHR( const PresentInfoKHR & presentInfo,
+                                            Dispatch const & d     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    //=== VK_EXT_debug_utils ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void
+      beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo,
                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename CheckpointData2NVAllocator = std::allocator<CheckpointData2NV>,
-              typename Dispatch                   = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD std::vector<CheckpointData2NV, CheckpointData2NVAllocator>
-                         getCheckpointData2NV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename CheckpointData2NVAllocator = std::allocator<CheckpointData2NV>,
-              typename Dispatch                   = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B                          = CheckpointData2NVAllocator,
-              typename std::enable_if<std::is_same<typename B::value_type, CheckpointData2NV>::value, int>::type = 0>
-    VULKAN_HPP_NODISCARD std::vector<CheckpointData2NV, CheckpointData2NVAllocator>
-                         getCheckpointData2NV( CheckpointData2NVAllocator & checkpointData2NVAllocator,
-                                               Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void
+      beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo,
+                               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 endDebugUtilsLabelEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void
+      insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo,
+                                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
+      insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo,
+                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    //=== VK_NV_device_diagnostic_checkpoints ===
+
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     void getCheckpointDataNV( uint32_t *                               pCheckpointDataCount,
                               VULKAN_HPP_NAMESPACE::CheckpointDataNV * pCheckpointData,
@@ -54153,54 +54237,7 @@ namespace VULKAN_HPP_NAMESPACE
                                               Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void
-      beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo,
-                               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
-      beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo,
-                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      bindSparse( uint32_t                                     bindInfoCount,
-                  const VULKAN_HPP_NAMESPACE::BindSparseInfo * pBindInfo,
-                  VULKAN_HPP_NAMESPACE::Fence                  fence,
-                  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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
-      bindSparse( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindSparseInfo> const & bindInfo,
-                  VULKAN_HPP_NAMESPACE::Fence fence                              VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
-                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void endDebugUtilsLabelEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void
-      insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo,
-                                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
-      insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo,
-                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      presentKHR( const VULKAN_HPP_NAMESPACE::PresentInfoKHR * pPresentInfo,
-                  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>
-    VULKAN_HPP_NODISCARD Result presentKHR( const PresentInfoKHR & presentInfo,
-                                            Dispatch const & d     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+    //=== VK_INTEL_performance_query ===
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -54210,23 +54247,11 @@ namespace VULKAN_HPP_NAMESPACE
 #else
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
-      setPerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,
-                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+         setPerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,
+                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      submit( uint32_t                                 submitCount,
-              const VULKAN_HPP_NAMESPACE::SubmitInfo * pSubmits,
-              VULKAN_HPP_NAMESPACE::Fence              fence,
-              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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
-      submit( ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo> const & submits,
-              VULKAN_HPP_NAMESPACE::Fence fence                          VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
-              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+    //=== VK_KHR_synchronization2 ===
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD Result
@@ -54242,14 +54267,22 @@ namespace VULKAN_HPP_NAMESPACE
                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#else
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
-         waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    void getCheckpointData2NV( uint32_t *                                pCheckpointDataCount,
+                               VULKAN_HPP_NAMESPACE::CheckpointData2NV * pCheckpointData,
+                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename CheckpointData2NVAllocator = std::allocator<CheckpointData2NV>,
+              typename Dispatch                   = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD std::vector<CheckpointData2NV, CheckpointData2NVAllocator>
+                         getCheckpointData2NV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <typename CheckpointData2NVAllocator = std::allocator<CheckpointData2NV>,
+              typename Dispatch                   = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B                          = CheckpointData2NVAllocator,
+              typename std::enable_if<std::is_same<typename B::value_type, CheckpointData2NV>::value, int>::type = 0>
+    VULKAN_HPP_NODISCARD std::vector<CheckpointData2NV, CheckpointData2NVAllocator>
+                         getCheckpointData2NV( CheckpointData2NVAllocator & checkpointData2NVAllocator,
+                                               Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkQueue() const VULKAN_HPP_NOEXCEPT
@@ -58689,165 +58722,51 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
-#if defined( VK_USE_PLATFORM_WIN32_KHR )
-#  ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    //=== VK_VERSION_1_0 ===
+
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result acquireFullScreenExclusiveModeEXT(
-      VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
-      Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#  else
+    PFN_vkVoidFunction
+      getProcAddr( const char *       pName,
+                   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>
+    PFN_vkVoidFunction
+      getProcAddr( const std::string & name,
+                   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;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void destroy( 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 getQueue( uint32_t                      queueFamilyIndex,
+                   uint32_t                      queueIndex,
+                   VULKAN_HPP_NAMESPACE::Queue * pQueue,
+                   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>
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Queue
+                         getQueue( uint32_t           queueFamilyIndex,
+                                   uint32_t           queueIndex,
+                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#else
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
-      acquireFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
-                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_USE_PLATFORM_WIN32_KHR*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      acquireNextImage2KHR( const VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR * pAcquireInfo,
-                            uint32_t *                                            pImageIndex,
-                            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>
-    VULKAN_HPP_NODISCARD ResultValue<uint32_t>
-                         acquireNextImage2KHR( const AcquireNextImageInfoKHR & acquireInfo,
-                                               Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+      waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      acquireNextImageKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
-                           uint64_t                           timeout,
-                           VULKAN_HPP_NAMESPACE::Semaphore    semaphore,
-                           VULKAN_HPP_NAMESPACE::Fence        fence,
-                           uint32_t *                         pImageIndex,
-                           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>
-    VULKAN_HPP_NODISCARD ResultValue<uint32_t>
-                         acquireNextImageKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR        swapchain,
-                                              uint64_t                                  timeout,
-                                              VULKAN_HPP_NAMESPACE::Semaphore semaphore VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
-                                              VULKAN_HPP_NAMESPACE::Fence fence         VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
-                                              Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result acquirePerformanceConfigurationINTEL(
-      const VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL * pAcquireInfo,
-      VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL *                  pConfiguration,
-      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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
-      typename ResultValueType<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL>::type
-      acquirePerformanceConfigurationINTEL( const PerformanceConfigurationAcquireInfoINTEL & acquireInfo,
-                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL, Dispatch>>::type
-      acquirePerformanceConfigurationINTELUnique( const PerformanceConfigurationAcquireInfoINTEL & acquireInfo,
-                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      acquireProfilingLockKHR( const VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR * pInfo,
-                               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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
-      acquireProfilingLockKHR( const AcquireProfilingLockInfoKHR & info,
-                               Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      allocateCommandBuffers( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo * pAllocateInfo,
-                              VULKAN_HPP_NAMESPACE::CommandBuffer *                   pCommandBuffers,
-                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename CommandBufferAllocator = std::allocator<CommandBuffer>,
-              typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
-      typename ResultValueType<std::vector<CommandBuffer, CommandBufferAllocator>>::type
-      allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo,
-                              Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename CommandBufferAllocator = std::allocator<CommandBuffer>,
-              typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B                      = CommandBufferAllocator,
-              typename std::enable_if<std::is_same<typename B::value_type, CommandBuffer>::value, int>::type = 0>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
-      typename ResultValueType<std::vector<CommandBuffer, CommandBufferAllocator>>::type
-      allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo,
-                              CommandBufferAllocator &          commandBufferAllocator,
-                              Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename CommandBufferAllocator = std::allocator<UniqueHandle<CommandBuffer, Dispatch>>>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
-      typename ResultValueType<std::vector<UniqueHandle<CommandBuffer, Dispatch>, CommandBufferAllocator>>::type
-      allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo,
-                                    Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <
-      typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-      typename CommandBufferAllocator    = std::allocator<UniqueHandle<CommandBuffer, Dispatch>>,
-      typename B                         = CommandBufferAllocator,
-      typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<CommandBuffer, Dispatch>>::value,
-                              int>::type = 0>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
-      typename ResultValueType<std::vector<UniqueHandle<CommandBuffer, Dispatch>, CommandBufferAllocator>>::type
-      allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo,
-                                    CommandBufferAllocator &          commandBufferAllocator,
-                                    Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      allocateDescriptorSets( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo * pAllocateInfo,
-                              VULKAN_HPP_NAMESPACE::DescriptorSet *                   pDescriptorSets,
-                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename DescriptorSetAllocator = std::allocator<DescriptorSet>,
-              typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
-      typename ResultValueType<std::vector<DescriptorSet, DescriptorSetAllocator>>::type
-      allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo,
-                              Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename DescriptorSetAllocator = std::allocator<DescriptorSet>,
-              typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B                      = DescriptorSetAllocator,
-              typename std::enable_if<std::is_same<typename B::value_type, DescriptorSet>::value, int>::type = 0>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
-      typename ResultValueType<std::vector<DescriptorSet, DescriptorSetAllocator>>::type
-      allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo,
-                              DescriptorSetAllocator &          descriptorSetAllocator,
-                              Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename DescriptorSetAllocator = std::allocator<UniqueHandle<DescriptorSet, Dispatch>>>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
-      typename ResultValueType<std::vector<UniqueHandle<DescriptorSet, Dispatch>, DescriptorSetAllocator>>::type
-      allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo,
-                                    Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <
-      typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-      typename DescriptorSetAllocator    = std::allocator<UniqueHandle<DescriptorSet, Dispatch>>,
-      typename B                         = DescriptorSetAllocator,
-      typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<DescriptorSet, Dispatch>>::value,
-                              int>::type = 0>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
-      typename ResultValueType<std::vector<UniqueHandle<DescriptorSet, Dispatch>, DescriptorSetAllocator>>::type
-      allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo,
-                                    DescriptorSetAllocator &          descriptorSetAllocator,
-                                    Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD Result
       allocateMemory( const VULKAN_HPP_NAMESPACE::MemoryAllocateInfo *  pAllocateInfo,
@@ -58872,15 +58791,82 @@ namespace VULKAN_HPP_NAMESPACE
 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result bindAccelerationStructureMemoryNV(
-      uint32_t                                                            bindInfoCount,
-      const VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV * pBindInfos,
+    void freeMemory( VULKAN_HPP_NAMESPACE::DeviceMemory                memory,
+                     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 freeMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory     VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
+                     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 free( VULKAN_HPP_NAMESPACE::DeviceMemory                memory,
+               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 free( VULKAN_HPP_NAMESPACE::DeviceMemory            memory,
+               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>
+    VULKAN_HPP_NODISCARD Result
+      mapMemory( VULKAN_HPP_NAMESPACE::DeviceMemory   memory,
+                 VULKAN_HPP_NAMESPACE::DeviceSize     offset,
+                 VULKAN_HPP_NAMESPACE::DeviceSize     size,
+                 VULKAN_HPP_NAMESPACE::MemoryMapFlags flags,
+                 void **                              ppData,
+                 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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void *>::type
+      mapMemory( VULKAN_HPP_NAMESPACE::DeviceMemory         memory,
+                 VULKAN_HPP_NAMESPACE::DeviceSize           offset,
+                 VULKAN_HPP_NAMESPACE::DeviceSize           size,
+                 VULKAN_HPP_NAMESPACE::MemoryMapFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
+                 Dispatch const & d                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void unmapMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory,
+                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      flushMappedMemoryRanges( uint32_t                                        memoryRangeCount,
+                               const VULKAN_HPP_NAMESPACE::MappedMemoryRange * pMemoryRanges,
+                               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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
+      flushMappedMemoryRanges( ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges,
+                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result invalidateMappedMemoryRanges(
+      uint32_t                                        memoryRangeCount,
+      const VULKAN_HPP_NAMESPACE::MappedMemoryRange * pMemoryRanges,
       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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type bindAccelerationStructureMemoryNV(
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV> const & bindInfos,
-      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
+      invalidateMappedMemoryRanges( ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges,
+                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void getMemoryCommitment( VULKAN_HPP_NAMESPACE::DeviceMemory memory,
+                              VULKAN_HPP_NAMESPACE::DeviceSize * pCommittedMemoryInBytes,
+                              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>
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceSize
+                         getMemoryCommitment( VULKAN_HPP_NAMESPACE::DeviceMemory memory,
+                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
@@ -58899,30 +58885,6 @@ namespace VULKAN_HPP_NAMESPACE
                         Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      bindBufferMemory2( uint32_t                                           bindInfoCount,
-                         const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo * pBindInfos,
-                         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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
-      bindBufferMemory2( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos,
-                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      bindBufferMemory2KHR( uint32_t                                           bindInfoCount,
-                            const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo * pBindInfos,
-                            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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
-      bindBufferMemory2KHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos,
-                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD Result
@@ -58940,162 +58902,343 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      bindImageMemory2( uint32_t                                          bindInfoCount,
-                        const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo * pBindInfos,
-                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+    void getBufferMemoryRequirements( VULKAN_HPP_NAMESPACE::Buffer               buffer,
+                                      VULKAN_HPP_NAMESPACE::MemoryRequirements * pMemoryRequirements,
+                                      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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
-      bindImageMemory2( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos,
-                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements getBufferMemoryRequirements(
+      VULKAN_HPP_NAMESPACE::Buffer buffer,
+      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 getImageMemoryRequirements( VULKAN_HPP_NAMESPACE::Image                image,
+                                     VULKAN_HPP_NAMESPACE::MemoryRequirements * pMemoryRequirements,
+                                     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>
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements getImageMemoryRequirements(
+      VULKAN_HPP_NAMESPACE::Image image,
+      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 getImageSparseMemoryRequirements(
+      VULKAN_HPP_NAMESPACE::Image                           image,
+      uint32_t *                                            pSparseMemoryRequirementCount,
+      VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements * pSparseMemoryRequirements,
+      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename SparseImageMemoryRequirementsAllocator = std::allocator<SparseImageMemoryRequirements>,
+              typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator>
+                         getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image,
+                                                           Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <typename SparseImageMemoryRequirementsAllocator = std::allocator<SparseImageMemoryRequirements>,
+              typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B                                      = SparseImageMemoryRequirementsAllocator,
+              typename std::enable_if<std::is_same<typename B::value_type, SparseImageMemoryRequirements>::value,
+                                      int>::type              = 0>
+    VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator>
+                         getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image              image,
+                                                           SparseImageMemoryRequirementsAllocator & sparseImageMemoryRequirementsAllocator,
+                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD Result
-      bindImageMemory2KHR( uint32_t                                          bindInfoCount,
-                           const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo * pBindInfos,
-                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+      createFence( const VULKAN_HPP_NAMESPACE::FenceCreateInfo *     pCreateInfo,
+                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                   VULKAN_HPP_NAMESPACE::Fence *                     pFence,
+                   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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
-      bindImageMemory2KHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos,
-                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::Fence>::type
+      createFence( const FenceCreateInfo &                       createInfo,
+                   Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                   Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>>::type
+      createFenceUnique( const FenceCreateInfo &                       createInfo,
+                         Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                         Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void destroyFence( VULKAN_HPP_NAMESPACE::Fence                       fence,
+                       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 destroyFence( VULKAN_HPP_NAMESPACE::Fence fence             VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
+                       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*/
 
-#if defined( VK_ENABLE_BETA_EXTENSIONS )
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result bindVideoSessionMemoryKHR(
-      VULKAN_HPP_NAMESPACE::VideoSessionKHR            videoSession,
-      uint32_t                                         videoSessionBindMemoryCount,
-      const VULKAN_HPP_NAMESPACE::VideoBindMemoryKHR * pVideoSessionBindMemories,
-      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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type bindVideoSessionMemoryKHR(
-      VULKAN_HPP_NAMESPACE::VideoSessionKHR                              videoSession,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::VideoBindMemoryKHR> const & videoSessionBindMemories,
-      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_ENABLE_BETA_EXTENSIONS*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result buildAccelerationStructuresKHR(
-      VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                   deferredOperation,
-      uint32_t                                                                     infoCount,
-      const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR *      pInfos,
-      const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos,
-      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+    void destroy( VULKAN_HPP_NAMESPACE::Fence                       fence,
+                  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>
-    Result buildAccelerationStructuresKHR(
-      VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                                     deferredOperation,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const &      infos,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos,
-      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
+    void destroy( VULKAN_HPP_NAMESPACE::Fence                   fence,
+                  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>
+    VULKAN_HPP_NODISCARD Result
+      resetFences( uint32_t                            fenceCount,
+                   const VULKAN_HPP_NAMESPACE::Fence * pFences,
+                   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>
+    typename ResultValueType<void>::type
+      resetFences( ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences,
+                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD Result
-      compileDeferredNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
-                         uint32_t                       shader,
-                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+      getFenceStatus( VULKAN_HPP_NAMESPACE::Fence fence,
+                      Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 #else
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
-      compileDeferredNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
-                         uint32_t                       shader,
-                         Dispatch const & d             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    VULKAN_HPP_NODISCARD Result getFenceStatus( VULKAN_HPP_NAMESPACE::Fence fence,
+                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result copyAccelerationStructureKHR(
-      VULKAN_HPP_NAMESPACE::DeferredOperationKHR                     deferredOperation,
-      const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR * pInfo,
-      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>
     VULKAN_HPP_NODISCARD Result
-      copyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
-                                    const CopyAccelerationStructureInfoKHR &   info,
-                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+      waitForFences( uint32_t                            fenceCount,
+                     const VULKAN_HPP_NAMESPACE::Fence * pFences,
+                     VULKAN_HPP_NAMESPACE::Bool32        waitAll,
+                     uint64_t                            timeout,
+                     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>
+    VULKAN_HPP_NODISCARD Result waitForFences( ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences,
+                                               VULKAN_HPP_NAMESPACE::Bool32                          waitAll,
+                                               uint64_t                                              timeout,
+                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result copyAccelerationStructureToMemoryKHR(
-      VULKAN_HPP_NAMESPACE::DeferredOperationKHR                             deferredOperation,
-      const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR * pInfo,
-      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>
     VULKAN_HPP_NODISCARD Result
-      copyAccelerationStructureToMemoryKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR       deferredOperation,
-                                            const CopyAccelerationStructureToMemoryInfoKHR & info,
-                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result copyMemoryToAccelerationStructureKHR(
-      VULKAN_HPP_NAMESPACE::DeferredOperationKHR                             deferredOperation,
-      const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR * pInfo,
-      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+      createSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo * pCreateInfo,
+                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                       VULKAN_HPP_NAMESPACE::Semaphore *                 pSemaphore,
+                       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>
-    VULKAN_HPP_NODISCARD Result
-      copyMemoryToAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR       deferredOperation,
-                                            const CopyMemoryToAccelerationStructureInfoKHR & info,
-                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result createAccelerationStructureKHR(
-      const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR * pCreateInfo,
-      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                pAllocator,
-      VULKAN_HPP_NAMESPACE::AccelerationStructureKHR *                 pAccelerationStructure,
-      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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
-      typename ResultValueType<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR>::type
-      createAccelerationStructureKHR( const AccelerationStructureCreateInfoKHR & createInfo,
-                                      Optional<const AllocationCallbacks> allocator
-                                                         VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::Semaphore>::type
+      createSemaphore( const SemaphoreCreateInfo &                   createInfo,
+                       Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                       Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR, Dispatch>>::type
-      createAccelerationStructureKHRUnique( const AccelerationStructureCreateInfoKHR & createInfo,
-                                            Optional<const AllocationCallbacks> allocator
-                                                               VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Semaphore, Dispatch>>::type
+      createSemaphoreUnique( const SemaphoreCreateInfo & createInfo,
+                             Optional<const AllocationCallbacks> allocator
+                                                VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result createAccelerationStructureNV(
-      const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV * pCreateInfo,
-      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *               pAllocator,
-      VULKAN_HPP_NAMESPACE::AccelerationStructureNV *                 pAccelerationStructure,
-      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+    void destroySemaphore( VULKAN_HPP_NAMESPACE::Semaphore                   semaphore,
+                           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>
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::AccelerationStructureNV>::type createAccelerationStructureNV(
-      const AccelerationStructureCreateInfoNV &     createInfo,
-      Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-      Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    void destroySemaphore( VULKAN_HPP_NAMESPACE::Semaphore semaphore     VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
+                           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( VULKAN_HPP_NAMESPACE::Semaphore                   semaphore,
+                  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::Semaphore               semaphore,
+                  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>
+    VULKAN_HPP_NODISCARD Result
+      createEvent( const VULKAN_HPP_NAMESPACE::EventCreateInfo *     pCreateInfo,
+                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                   VULKAN_HPP_NAMESPACE::Event *                     pEvent,
+                   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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::Event>::type
+      createEvent( const EventCreateInfo &                       createInfo,
+                   Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                   Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_INLINE
-      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::AccelerationStructureNV, Dispatch>>::type
-      createAccelerationStructureNVUnique( const AccelerationStructureCreateInfoNV & createInfo,
-                                           Optional<const AllocationCallbacks> allocator
-                                                              VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Event, Dispatch>>::type
+      createEventUnique( const EventCreateInfo &                       createInfo,
+                         Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                         Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void destroyEvent( VULKAN_HPP_NAMESPACE::Event                       event,
+                       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 destroyEvent( VULKAN_HPP_NAMESPACE::Event event             VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
+                       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( VULKAN_HPP_NAMESPACE::Event                       event,
+                  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::Event                   event,
+                  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*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      getEventStatus( VULKAN_HPP_NAMESPACE::Event event,
+                      Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#else
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result getEventStatus( VULKAN_HPP_NAMESPACE::Event event,
+                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      setEvent( VULKAN_HPP_NAMESPACE::Event event,
+                Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#else
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
+      setEvent( VULKAN_HPP_NAMESPACE::Event event, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      resetEvent( VULKAN_HPP_NAMESPACE::Event event,
+                  Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#else
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    typename ResultValueType<void>::type
+      resetEvent( VULKAN_HPP_NAMESPACE::Event event,
+                  Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      createQueryPool( const VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo * pCreateInfo,
+                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                       VULKAN_HPP_NAMESPACE::QueryPool *                 pQueryPool,
+                       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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::QueryPool>::type
+      createQueryPool( const QueryPoolCreateInfo &                   createInfo,
+                       Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                       Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::QueryPool, Dispatch>>::type
+      createQueryPoolUnique( const QueryPoolCreateInfo & createInfo,
+                             Optional<const AllocationCallbacks> allocator
+                                                VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void destroyQueryPool( VULKAN_HPP_NAMESPACE::QueryPool                   queryPool,
+                           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 destroyQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool     VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
+                           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( VULKAN_HPP_NAMESPACE::QueryPool                   queryPool,
+                  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::QueryPool               queryPool,
+                  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>
+    VULKAN_HPP_NODISCARD Result
+      getQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool        queryPool,
+                           uint32_t                               firstQuery,
+                           uint32_t                               queryCount,
+                           size_t                                 dataSize,
+                           void *                                 pData,
+                           VULKAN_HPP_NAMESPACE::DeviceSize       stride,
+                           VULKAN_HPP_NAMESPACE::QueryResultFlags flags,
+                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      getQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool        queryPool,
+                           uint32_t                               firstQuery,
+                           uint32_t                               queryCount,
+                           ArrayProxy<T> const &                  data,
+                           VULKAN_HPP_NAMESPACE::DeviceSize       stride,
+                           VULKAN_HPP_NAMESPACE::QueryResultFlags flags,
+                           Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <typename T,
+              typename Allocator = std::allocator<T>,
+              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD ResultValue<std::vector<T, Allocator>>
+                         getQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool              queryPool,
+                                              uint32_t                                     firstQuery,
+                                              uint32_t                                     queryCount,
+                                              size_t                                       dataSize,
+                                              VULKAN_HPP_NAMESPACE::DeviceSize             stride,
+                                              VULKAN_HPP_NAMESPACE::QueryResultFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
+                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD ResultValue<T>
+                         getQueryPoolResult( VULKAN_HPP_NAMESPACE::QueryPool              queryPool,
+                                             uint32_t                                     firstQuery,
+                                             uint32_t                                     queryCount,
+                                             VULKAN_HPP_NAMESPACE::DeviceSize             stride,
+                                             VULKAN_HPP_NAMESPACE::QueryResultFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
+                                             Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD Result
       createBuffer( const VULKAN_HPP_NAMESPACE::BufferCreateInfo *    pCreateInfo,
@@ -59118,6 +59261,28 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #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,
+                        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 destroyBuffer( VULKAN_HPP_NAMESPACE::Buffer buffer           VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
+                        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( VULKAN_HPP_NAMESPACE::Buffer                      buffer,
+                  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::Buffer                  buffer,
+                  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>
     VULKAN_HPP_NODISCARD Result
       createBufferView( const VULKAN_HPP_NAMESPACE::BufferViewCreateInfo * pCreateInfo,
@@ -59142,25 +59307,318 @@ namespace VULKAN_HPP_NAMESPACE
 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      createCommandPool( const VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo * pCreateInfo,
-                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
-                         VULKAN_HPP_NAMESPACE::CommandPool *                 pCommandPool,
-                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+    void destroyBufferView( VULKAN_HPP_NAMESPACE::BufferView                  bufferView,
+                            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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::CommandPool>::type
-      createCommandPool( const CommandPoolCreateInfo &                 createInfo,
+    void
+      destroyBufferView( VULKAN_HPP_NAMESPACE::BufferView bufferView   VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
                          Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                         Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+                         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::BufferView                  bufferView,
+                  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::BufferView              bufferView,
+                  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>
+    VULKAN_HPP_NODISCARD Result
+      createImage( const VULKAN_HPP_NAMESPACE::ImageCreateInfo *     pCreateInfo,
+                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                   VULKAN_HPP_NAMESPACE::Image *                     pImage,
+                   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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::Image>::type
+      createImage( const ImageCreateInfo &                       createInfo,
+                   Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                   Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandPool, Dispatch>>::type
-      createCommandPoolUnique( const CommandPoolCreateInfo & createInfo,
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Image, Dispatch>>::type
+      createImageUnique( const ImageCreateInfo &                       createInfo,
+                         Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                         Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void destroyImage( VULKAN_HPP_NAMESPACE::Image                       image,
+                       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 destroyImage( VULKAN_HPP_NAMESPACE::Image image             VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
+                       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( VULKAN_HPP_NAMESPACE::Image                       image,
+                  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::Image                   image,
+                  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 getImageSubresourceLayout( VULKAN_HPP_NAMESPACE::Image                    image,
+                                    const VULKAN_HPP_NAMESPACE::ImageSubresource * pSubresource,
+                                    VULKAN_HPP_NAMESPACE::SubresourceLayout *      pLayout,
+                                    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>
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SubresourceLayout getImageSubresourceLayout(
+      VULKAN_HPP_NAMESPACE::Image image,
+      const ImageSubresource &    subresource,
+      Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      createImageView( const VULKAN_HPP_NAMESPACE::ImageViewCreateInfo * pCreateInfo,
+                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                       VULKAN_HPP_NAMESPACE::ImageView *                 pView,
+                       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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageView>::type
+      createImageView( const ImageViewCreateInfo &                   createInfo,
+                       Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                       Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ImageView, Dispatch>>::type
+      createImageViewUnique( const ImageViewCreateInfo & createInfo,
+                             Optional<const AllocationCallbacks> allocator
+                                                VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void destroyImageView( VULKAN_HPP_NAMESPACE::ImageView                   imageView,
+                           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 destroyImageView( VULKAN_HPP_NAMESPACE::ImageView imageView     VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
+                           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( VULKAN_HPP_NAMESPACE::ImageView                   imageView,
+                  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::ImageView               imageView,
+                  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>
+    VULKAN_HPP_NODISCARD Result
+      createShaderModule( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo * pCreateInfo,
+                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks *    pAllocator,
+                          VULKAN_HPP_NAMESPACE::ShaderModule *                 pShaderModule,
+                          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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::ShaderModule>::type
+      createShaderModule( const ShaderModuleCreateInfo &                createInfo,
+                          Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderModule, Dispatch>>::type
+      createShaderModuleUnique( const ShaderModuleCreateInfo & createInfo,
+                                Optional<const AllocationCallbacks> allocator
+                                                   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void destroyShaderModule( VULKAN_HPP_NAMESPACE::ShaderModule                shaderModule,
+                              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
+      destroyShaderModule( VULKAN_HPP_NAMESPACE::ShaderModule shaderModule VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
+                           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( VULKAN_HPP_NAMESPACE::ShaderModule                shaderModule,
+                  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::ShaderModule            shaderModule,
+                  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>
+    VULKAN_HPP_NODISCARD Result
+      createPipelineCache( const VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo * pCreateInfo,
+                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks *     pAllocator,
+                           VULKAN_HPP_NAMESPACE::PipelineCache *                 pPipelineCache,
+                           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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::PipelineCache>::type
+      createPipelineCache( const PipelineCacheCreateInfo &               createInfo,
+                           Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineCache, Dispatch>>::type
+      createPipelineCacheUnique( const PipelineCacheCreateInfo & createInfo,
+                                 Optional<const AllocationCallbacks> allocator
+                                                    VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void destroyPipelineCache( VULKAN_HPP_NAMESPACE::PipelineCache               pipelineCache,
+                               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 destroyPipelineCache( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
                                Optional<const AllocationCallbacks> allocator
                                                   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+                               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::PipelineCache               pipelineCache,
+                  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::PipelineCache           pipelineCache,
+                  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>
+    VULKAN_HPP_NODISCARD Result
+      getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
+                            size_t *                            pDataSize,
+                            void *                              pData,
+                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename Uint8_tAllocator = std::allocator<uint8_t>,
+              typename Dispatch         = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
+      getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
+                            Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <typename Uint8_tAllocator = std::allocator<uint8_t>,
+              typename Dispatch         = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B                = Uint8_tAllocator,
+              typename std::enable_if<std::is_same<typename B::value_type, uint8_t>::value, int>::type = 0>
+    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
+      getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
+                            Uint8_tAllocator &                  uint8_tAllocator,
+                            Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      mergePipelineCaches( VULKAN_HPP_NAMESPACE::PipelineCache         dstCache,
+                           uint32_t                                    srcCacheCount,
+                           const VULKAN_HPP_NAMESPACE::PipelineCache * pSrcCaches,
+                           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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
+      mergePipelineCaches( VULKAN_HPP_NAMESPACE::PipelineCache                           dstCache,
+                           ArrayProxy<const VULKAN_HPP_NAMESPACE::PipelineCache> const & srcCaches,
+                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      createGraphicsPipelines( VULKAN_HPP_NAMESPACE::PipelineCache                      pipelineCache,
+                               uint32_t                                                 createInfoCount,
+                               const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo * pCreateInfos,
+                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks *        pAllocator,
+                               VULKAN_HPP_NAMESPACE::Pipeline *                         pPipelines,
+                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename PipelineAllocator = std::allocator<Pipeline>,
+              typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, PipelineAllocator>> createGraphicsPipelines(
+      VULKAN_HPP_NAMESPACE::PipelineCache                                        pipelineCache,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
+      Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+      Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <typename PipelineAllocator = std::allocator<Pipeline>,
+              typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B                 = PipelineAllocator,
+              typename std::enable_if<std::is_same<typename B::value_type, Pipeline>::value, int>::type = 0>
+    VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, PipelineAllocator>>
+                         createGraphicsPipelines( VULKAN_HPP_NAMESPACE::PipelineCache                                        pipelineCache,
+                                                  ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
+                                                  Optional<const AllocationCallbacks>                                        allocator,
+                                                  PipelineAllocator & pipelineAllocator,
+                                                  Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD ResultValue<Pipeline> createGraphicsPipeline(
+      VULKAN_HPP_NAMESPACE::PipelineCache                      pipelineCache,
+      const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo & createInfo,
+      Optional<const AllocationCallbacks> allocator            VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+      Dispatch const & d                                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template <typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename PipelineAllocator = std::allocator<UniqueHandle<Pipeline, Dispatch>>>
+    VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
+                         createGraphicsPipelinesUnique(
+                           VULKAN_HPP_NAMESPACE::PipelineCache                                        pipelineCache,
+                           ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
+                           Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                           Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename PipelineAllocator         = std::allocator<UniqueHandle<Pipeline, Dispatch>>,
+              typename B                         = PipelineAllocator,
+              typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<Pipeline, Dispatch>>::value,
+                                      int>::type = 0>
+    VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
+                         createGraphicsPipelinesUnique(
+                           VULKAN_HPP_NAMESPACE::PipelineCache                                        pipelineCache,
+                           ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
+                           Optional<const AllocationCallbacks>                                        allocator,
+                           PipelineAllocator &                                                        pipelineAllocator,
+                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<Pipeline, Dispatch>> createGraphicsPipelineUnique(
+      VULKAN_HPP_NAMESPACE::PipelineCache                      pipelineCache,
+      const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo & createInfo,
+      Optional<const AllocationCallbacks> allocator            VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+      Dispatch const & d                                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -59227,69 +59685,165 @@ namespace VULKAN_HPP_NAMESPACE
 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      createCuFunctionNVX( const VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX * pCreateInfo,
-                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks *     pAllocator,
-                           VULKAN_HPP_NAMESPACE::CuFunctionNVX *                 pFunction,
-                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+    void destroyPipeline( VULKAN_HPP_NAMESPACE::Pipeline                    pipeline,
+                          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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::CuFunctionNVX>::type
-      createCuFunctionNVX( const CuFunctionCreateInfoNVX &               createInfo,
-                           Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    void destroyPipeline( VULKAN_HPP_NAMESPACE::Pipeline pipeline       VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
+                          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( VULKAN_HPP_NAMESPACE::Pipeline                    pipeline,
+                  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::Pipeline                pipeline,
+                  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>
+    VULKAN_HPP_NODISCARD Result
+      createPipelineLayout( const VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo * pCreateInfo,
+                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks *      pAllocator,
+                            VULKAN_HPP_NAMESPACE::PipelineLayout *                 pPipelineLayout,
+                            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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::PipelineLayout>::type
+      createPipelineLayout( const PipelineLayoutCreateInfo & createInfo,
+                            Optional<const AllocationCallbacks> allocator
+                                               VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CuFunctionNVX, Dispatch>>::type
-      createCuFunctionNVXUnique( const CuFunctionCreateInfoNVX & createInfo,
-                                 Optional<const AllocationCallbacks> allocator
-                                                    VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineLayout, Dispatch>>::type
+      createPipelineLayoutUnique( const PipelineLayoutCreateInfo & createInfo,
+                                  Optional<const AllocationCallbacks> allocator
+                                                     VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void destroyPipelineLayout( VULKAN_HPP_NAMESPACE::PipelineLayout              pipelineLayout,
+                                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 destroyPipelineLayout(
+      VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
+      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( VULKAN_HPP_NAMESPACE::PipelineLayout              pipelineLayout,
+                  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::PipelineLayout          pipelineLayout,
+                  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>
     VULKAN_HPP_NODISCARD Result
-      createCuModuleNVX( const VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX * pCreateInfo,
-                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
-                         VULKAN_HPP_NAMESPACE::CuModuleNVX *                 pModule,
+      createSampler( const VULKAN_HPP_NAMESPACE::SamplerCreateInfo *   pCreateInfo,
+                     const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                     VULKAN_HPP_NAMESPACE::Sampler *                   pSampler,
+                     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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::Sampler>::type
+      createSampler( const SamplerCreateInfo &                     createInfo,
+                     Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                     Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Sampler, Dispatch>>::type
+      createSamplerUnique( const SamplerCreateInfo &                     createInfo,
+                           Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void destroySampler( VULKAN_HPP_NAMESPACE::Sampler                     sampler,
+                         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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::CuModuleNVX>::type
-      createCuModuleNVX( const CuModuleCreateInfoNVX &                 createInfo,
+    void destroySampler( VULKAN_HPP_NAMESPACE::Sampler sampler         VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
                          Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                         Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+                         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::Sampler                     sampler,
+                  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::Sampler                 sampler,
+                  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>
+    VULKAN_HPP_NODISCARD Result createDescriptorSetLayout(
+      const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo * pCreateInfo,
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *           pAllocator,
+      VULKAN_HPP_NAMESPACE::DescriptorSetLayout *                 pSetLayout,
+      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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorSetLayout>::type
+      createDescriptorSetLayout( const DescriptorSetLayoutCreateInfo & createInfo,
+                                 Optional<const AllocationCallbacks> allocator
+                                                    VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CuModuleNVX, Dispatch>>::type
-      createCuModuleNVXUnique( const CuModuleCreateInfoNVX & createInfo,
-                               Optional<const AllocationCallbacks> allocator
-                                                  VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSetLayout, Dispatch>>::type
+      createDescriptorSetLayoutUnique( const DescriptorSetLayoutCreateInfo & createInfo,
+                                       Optional<const AllocationCallbacks> allocator
+                                                          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result createDeferredOperationKHR(
-      const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-      VULKAN_HPP_NAMESPACE::DeferredOperationKHR *      pDeferredOperation,
-      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+    void destroyDescriptorSetLayout( VULKAN_HPP_NAMESPACE::DescriptorSetLayout         descriptorSetLayout,
+                                     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>
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::DeferredOperationKHR>::type createDeferredOperationKHR(
-      Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-      Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+    void destroyDescriptorSetLayout(
+      VULKAN_HPP_NAMESPACE::DescriptorSetLayout descriptorSetLayout VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
+      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>
-    VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DeferredOperationKHR, Dispatch>>::type
-      createDeferredOperationKHRUnique( Optional<const AllocationCallbacks> allocator
-                                                           VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+    void destroy( VULKAN_HPP_NAMESPACE::DescriptorSetLayout         descriptorSetLayout,
+                  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::DescriptorSetLayout     descriptorSetLayout,
+                  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>
     VULKAN_HPP_NODISCARD Result
@@ -59316,29 +59870,514 @@ namespace VULKAN_HPP_NAMESPACE
 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result createDescriptorSetLayout(
-      const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo * pCreateInfo,
-      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *           pAllocator,
-      VULKAN_HPP_NAMESPACE::DescriptorSetLayout *                 pSetLayout,
-      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+    void destroyDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool              descriptorPool,
+                                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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorSetLayout>::type
-      createDescriptorSetLayout( const DescriptorSetLayoutCreateInfo & createInfo,
-                                 Optional<const AllocationCallbacks> allocator
-                                                    VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    void destroyDescriptorPool(
+      VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
+      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( VULKAN_HPP_NAMESPACE::DescriptorPool              descriptorPool,
+                  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::DescriptorPool          descriptorPool,
+                  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*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    Result resetDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool           descriptorPool,
+                                VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags,
+                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#else
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    typename ResultValueType<void>::type
+      resetDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool                 descriptorPool,
+                           VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
+                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      allocateDescriptorSets( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo * pAllocateInfo,
+                              VULKAN_HPP_NAMESPACE::DescriptorSet *                   pDescriptorSets,
+                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename DescriptorSetAllocator = std::allocator<DescriptorSet>,
+              typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
+      typename ResultValueType<std::vector<DescriptorSet, DescriptorSetAllocator>>::type
+      allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo,
+                              Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <typename DescriptorSetAllocator = std::allocator<DescriptorSet>,
+              typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B                      = DescriptorSetAllocator,
+              typename std::enable_if<std::is_same<typename B::value_type, DescriptorSet>::value, int>::type = 0>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
+      typename ResultValueType<std::vector<DescriptorSet, DescriptorSetAllocator>>::type
+      allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo,
+                              DescriptorSetAllocator &          descriptorSetAllocator,
+                              Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template <typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename DescriptorSetAllocator = std::allocator<UniqueHandle<DescriptorSet, Dispatch>>>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
+      typename ResultValueType<std::vector<UniqueHandle<DescriptorSet, Dispatch>, DescriptorSetAllocator>>::type
+      allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo,
+                                    Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <
+      typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+      typename DescriptorSetAllocator    = std::allocator<UniqueHandle<DescriptorSet, Dispatch>>,
+      typename B                         = DescriptorSetAllocator,
+      typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<DescriptorSet, Dispatch>>::value,
+                              int>::type = 0>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
+      typename ResultValueType<std::vector<UniqueHandle<DescriptorSet, Dispatch>, DescriptorSetAllocator>>::type
+      allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo,
+                                    DescriptorSetAllocator &          descriptorSetAllocator,
+                                    Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    Result freeDescriptorSets( VULKAN_HPP_NAMESPACE::DescriptorPool        descriptorPool,
+                               uint32_t                                    descriptorSetCount,
+                               const VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets,
+                               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>
+    typename ResultValueType<void>::type
+      freeDescriptorSets( VULKAN_HPP_NAMESPACE::DescriptorPool                          descriptorPool,
+                          ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets,
+                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    Result free( VULKAN_HPP_NAMESPACE::DescriptorPool        descriptorPool,
+                 uint32_t                                    descriptorSetCount,
+                 const VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets,
+                 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>
+    typename ResultValueType<void>::type
+      free( VULKAN_HPP_NAMESPACE::DescriptorPool                          descriptorPool,
+            ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets,
+            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void updateDescriptorSets( uint32_t                                         descriptorWriteCount,
+                               const VULKAN_HPP_NAMESPACE::WriteDescriptorSet * pDescriptorWrites,
+                               uint32_t                                         descriptorCopyCount,
+                               const VULKAN_HPP_NAMESPACE::CopyDescriptorSet *  pDescriptorCopies,
+                               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 updateDescriptorSets( ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites,
+                               ArrayProxy<const VULKAN_HPP_NAMESPACE::CopyDescriptorSet> const &  descriptorCopies,
+                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      createFramebuffer( const VULKAN_HPP_NAMESPACE::FramebufferCreateInfo * pCreateInfo,
+                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
+                         VULKAN_HPP_NAMESPACE::Framebuffer *                 pFramebuffer,
+                         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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::Framebuffer>::type
+      createFramebuffer( const FramebufferCreateInfo &                 createInfo,
+                         Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                         Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSetLayout, Dispatch>>::type
-      createDescriptorSetLayoutUnique( const DescriptorSetLayoutCreateInfo & createInfo,
-                                       Optional<const AllocationCallbacks> allocator
-                                                          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Framebuffer, Dispatch>>::type
+      createFramebufferUnique( const FramebufferCreateInfo & createInfo,
+                               Optional<const AllocationCallbacks> allocator
+                                                  VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void destroyFramebuffer( VULKAN_HPP_NAMESPACE::Framebuffer                 framebuffer,
+                             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
+      destroyFramebuffer( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
+                          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( VULKAN_HPP_NAMESPACE::Framebuffer                 framebuffer,
+                  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::Framebuffer             framebuffer,
+                  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>
+    VULKAN_HPP_NODISCARD Result
+      createRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo * pCreateInfo,
+                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks *  pAllocator,
+                        VULKAN_HPP_NAMESPACE::RenderPass *                 pRenderPass,
+                        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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::RenderPass>::type
+      createRenderPass( const RenderPassCreateInfo &                  createInfo,
+                        Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                        Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type
+      createRenderPassUnique( const RenderPassCreateInfo & createInfo,
+                              Optional<const AllocationCallbacks> allocator
+                                                 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void destroyRenderPass( VULKAN_HPP_NAMESPACE::RenderPass                  renderPass,
+                            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
+      destroyRenderPass( VULKAN_HPP_NAMESPACE::RenderPass renderPass   VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
+                         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( VULKAN_HPP_NAMESPACE::RenderPass                  renderPass,
+                  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::RenderPass              renderPass,
+                  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
+      getRenderAreaGranularity( VULKAN_HPP_NAMESPACE::RenderPass renderPass,
+                                VULKAN_HPP_NAMESPACE::Extent2D * pGranularity,
+                                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>
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Extent2D
+                         getRenderAreaGranularity( VULKAN_HPP_NAMESPACE::RenderPass renderPass,
+                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      createCommandPool( const VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo * pCreateInfo,
+                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
+                         VULKAN_HPP_NAMESPACE::CommandPool *                 pCommandPool,
+                         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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::CommandPool>::type
+      createCommandPool( const CommandPoolCreateInfo &                 createInfo,
+                         Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                         Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandPool, Dispatch>>::type
+      createCommandPoolUnique( const CommandPoolCreateInfo & createInfo,
+                               Optional<const AllocationCallbacks> allocator
+                                                  VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void destroyCommandPool( VULKAN_HPP_NAMESPACE::CommandPool                 commandPool,
+                             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
+      destroyCommandPool( VULKAN_HPP_NAMESPACE::CommandPool commandPool VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
+                          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( VULKAN_HPP_NAMESPACE::CommandPool                 commandPool,
+                  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::CommandPool             commandPool,
+                  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*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      resetCommandPool( VULKAN_HPP_NAMESPACE::CommandPool           commandPool,
+                        VULKAN_HPP_NAMESPACE::CommandPoolResetFlags flags,
+                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#else
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    typename ResultValueType<void>::type
+      resetCommandPool( VULKAN_HPP_NAMESPACE::CommandPool                 commandPool,
+                        VULKAN_HPP_NAMESPACE::CommandPoolResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
+                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      allocateCommandBuffers( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo * pAllocateInfo,
+                              VULKAN_HPP_NAMESPACE::CommandBuffer *                   pCommandBuffers,
+                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename CommandBufferAllocator = std::allocator<CommandBuffer>,
+              typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
+      typename ResultValueType<std::vector<CommandBuffer, CommandBufferAllocator>>::type
+      allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo,
+                              Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <typename CommandBufferAllocator = std::allocator<CommandBuffer>,
+              typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B                      = CommandBufferAllocator,
+              typename std::enable_if<std::is_same<typename B::value_type, CommandBuffer>::value, int>::type = 0>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
+      typename ResultValueType<std::vector<CommandBuffer, CommandBufferAllocator>>::type
+      allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo,
+                              CommandBufferAllocator &          commandBufferAllocator,
+                              Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template <typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename CommandBufferAllocator = std::allocator<UniqueHandle<CommandBuffer, Dispatch>>>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
+      typename ResultValueType<std::vector<UniqueHandle<CommandBuffer, Dispatch>, CommandBufferAllocator>>::type
+      allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo,
+                                    Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <
+      typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+      typename CommandBufferAllocator    = std::allocator<UniqueHandle<CommandBuffer, Dispatch>>,
+      typename B                         = CommandBufferAllocator,
+      typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<CommandBuffer, Dispatch>>::value,
+                              int>::type = 0>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
+      typename ResultValueType<std::vector<UniqueHandle<CommandBuffer, Dispatch>, CommandBufferAllocator>>::type
+      allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo,
+                                    CommandBufferAllocator &          commandBufferAllocator,
+                                    Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void freeCommandBuffers( VULKAN_HPP_NAMESPACE::CommandPool           commandPool,
+                             uint32_t                                    commandBufferCount,
+                             const VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers,
+                             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 freeCommandBuffers( VULKAN_HPP_NAMESPACE::CommandPool                             commandPool,
+                             ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers,
+                             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 free( VULKAN_HPP_NAMESPACE::CommandPool           commandPool,
+               uint32_t                                    commandBufferCount,
+               const VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers,
+               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 free( VULKAN_HPP_NAMESPACE::CommandPool                             commandPool,
+               ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers,
+               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    //=== VK_VERSION_1_1 ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      bindBufferMemory2( uint32_t                                           bindInfoCount,
+                         const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo * pBindInfos,
+                         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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
+      bindBufferMemory2( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos,
+                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      bindImageMemory2( uint32_t                                          bindInfoCount,
+                        const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo * pBindInfos,
+                        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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
+      bindImageMemory2( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos,
+                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void getGroupPeerMemoryFeatures( uint32_t                                       heapIndex,
+                                     uint32_t                                       localDeviceIndex,
+                                     uint32_t                                       remoteDeviceIndex,
+                                     VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags * pPeerMemoryFeatures,
+                                     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>
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags getGroupPeerMemoryFeatures(
+      uint32_t           heapIndex,
+      uint32_t           localDeviceIndex,
+      uint32_t           remoteDeviceIndex,
+      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 getImageMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 * pInfo,
+                                      VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                pMemoryRequirements,
+                                      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>
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getImageMemoryRequirements2(
+      const ImageMemoryRequirementsInfo2 & info,
+      Dispatch const & d                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getImageMemoryRequirements2(
+      const ImageMemoryRequirementsInfo2 & info,
+      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 getBufferMemoryRequirements2( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 * pInfo,
+                                       VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                 pMemoryRequirements,
+                                       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>
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getBufferMemoryRequirements2(
+      const BufferMemoryRequirementsInfo2 & info,
+      Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getBufferMemoryRequirements2(
+      const BufferMemoryRequirementsInfo2 & info,
+      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 getImageSparseMemoryRequirements2(
+      const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 * pInfo,
+      uint32_t *                                                       pSparseMemoryRequirementCount,
+      VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 *           pSparseMemoryRequirements,
+      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename SparseImageMemoryRequirements2Allocator = std::allocator<SparseImageMemoryRequirements2>,
+              typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
+                         getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info,
+                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <typename SparseImageMemoryRequirements2Allocator = std::allocator<SparseImageMemoryRequirements2>,
+              typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B                                       = SparseImageMemoryRequirements2Allocator,
+              typename std::enable_if<std::is_same<typename B::value_type, SparseImageMemoryRequirements2>::value,
+                                      int>::type               = 0>
+    VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
+                         getImageSparseMemoryRequirements2(
+                           const ImageSparseMemoryRequirementsInfo2 & info,
+                           SparseImageMemoryRequirements2Allocator &  sparseImageMemoryRequirements2Allocator,
+                           Dispatch const & d                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void trimCommandPool( VULKAN_HPP_NAMESPACE::CommandPool          commandPool,
+                          VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags,
+                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void getQueue2( const VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 * pQueueInfo,
+                    VULKAN_HPP_NAMESPACE::Queue *                  pQueue,
+                    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>
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Queue
+                         getQueue2( const DeviceQueueInfo2 & queueInfo,
+                                    Dispatch const & d       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result createSamplerYcbcrConversion(
+      const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo * pCreateInfo,
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *              pAllocator,
+      VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion *                 pYcbcrConversion,
+      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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>::type
+      createSamplerYcbcrConversion( const SamplerYcbcrConversionCreateInfo & createInfo,
+                                    Optional<const AllocationCallbacks> allocator
+                                                       VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, Dispatch>>::type
+      createSamplerYcbcrConversionUnique( const SamplerYcbcrConversionCreateInfo & createInfo,
+                                          Optional<const AllocationCallbacks> allocator
+                                                             VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void destroySamplerYcbcrConversion( 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 destroySamplerYcbcrConversion(
+      VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
+      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( 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>
     VULKAN_HPP_NODISCARD Result createDescriptorUpdateTemplate(
       const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo * pCreateInfo,
@@ -59364,6 +60403,821 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void destroyDescriptorUpdateTemplate( 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 destroyDescriptorUpdateTemplate(
+      VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
+      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( 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 updateDescriptorSetWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorSet            descriptorSet,
+                                          VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
+                                          const void *                                   pData,
+                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
+      VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void getDescriptorSetLayoutSupport( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo * pCreateInfo,
+                                        VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport *          pSupport,
+                                        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>
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport getDescriptorSetLayoutSupport(
+      const DescriptorSetLayoutCreateInfo & createInfo,
+      Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getDescriptorSetLayoutSupport(
+      const DescriptorSetLayoutCreateInfo & createInfo,
+      Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    //=== VK_VERSION_1_2 ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      createRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 * pCreateInfo,
+                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
+                         VULKAN_HPP_NAMESPACE::RenderPass *                  pRenderPass,
+                         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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::RenderPass>::type
+      createRenderPass2( const RenderPassCreateInfo2 &                 createInfo,
+                         Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                         Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type
+      createRenderPass2Unique( const RenderPassCreateInfo2 & createInfo,
+                               Optional<const AllocationCallbacks> allocator
+                                                  VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void resetQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
+                         uint32_t                        firstQuery,
+                         uint32_t                        queryCount,
+                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      getSemaphoreCounterValue( VULKAN_HPP_NAMESPACE::Semaphore semaphore,
+                                uint64_t *                      pValue,
+                                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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<uint64_t>::type
+      getSemaphoreCounterValue( VULKAN_HPP_NAMESPACE::Semaphore semaphore,
+                                Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      waitSemaphores( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo * pWaitInfo,
+                      uint64_t                                        timeout,
+                      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>
+    VULKAN_HPP_NODISCARD Result waitSemaphores( const SemaphoreWaitInfo & waitInfo,
+                                                uint64_t                  timeout,
+                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      signalSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo * pSignalInfo,
+                       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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
+      signalSemaphore( const SemaphoreSignalInfo & signalInfo,
+                       Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    DeviceAddress
+      getBufferAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,
+                        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>
+    DeviceAddress
+      getBufferAddress( const BufferDeviceAddressInfo & info,
+                        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>
+    uint64_t getBufferOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,
+                                            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>
+    uint64_t getBufferOpaqueCaptureAddress( const BufferDeviceAddressInfo & info,
+                                            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>
+    uint64_t getMemoryOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo * pInfo,
+                                            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>
+    uint64_t getMemoryOpaqueCaptureAddress( const DeviceMemoryOpaqueCaptureAddressInfo & info,
+                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
+      VULKAN_HPP_NOEXCEPT;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    //=== VK_KHR_swapchain ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      createSwapchainKHR( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR * pCreateInfo,
+                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks *    pAllocator,
+                          VULKAN_HPP_NAMESPACE::SwapchainKHR *                 pSwapchain,
+                          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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SwapchainKHR>::type
+      createSwapchainKHR( const SwapchainCreateInfoKHR &                createInfo,
+                          Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>::type
+      createSwapchainKHRUnique( const SwapchainCreateInfoKHR & createInfo,
+                                Optional<const AllocationCallbacks> allocator
+                                                   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void destroySwapchainKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR                swapchain,
+                              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
+      destroySwapchainKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain  VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
+                           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( VULKAN_HPP_NAMESPACE::SwapchainKHR                swapchain,
+                  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::SwapchainKHR            swapchain,
+                  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>
+    VULKAN_HPP_NODISCARD Result
+      getSwapchainImagesKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
+                             uint32_t *                         pSwapchainImageCount,
+                             VULKAN_HPP_NAMESPACE::Image *      pSwapchainImages,
+                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename ImageAllocator = std::allocator<Image>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<Image, ImageAllocator>>::type
+      getSwapchainImagesKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
+                             Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <typename ImageAllocator = std::allocator<Image>,
+              typename Dispatch       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B              = ImageAllocator,
+              typename std::enable_if<std::is_same<typename B::value_type, Image>::value, int>::type = 0>
+    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<Image, ImageAllocator>>::type
+      getSwapchainImagesKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
+                             ImageAllocator &                   imageAllocator,
+                             Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      acquireNextImageKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
+                           uint64_t                           timeout,
+                           VULKAN_HPP_NAMESPACE::Semaphore    semaphore,
+                           VULKAN_HPP_NAMESPACE::Fence        fence,
+                           uint32_t *                         pImageIndex,
+                           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>
+    VULKAN_HPP_NODISCARD ResultValue<uint32_t>
+                         acquireNextImageKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR        swapchain,
+                                              uint64_t                                  timeout,
+                                              VULKAN_HPP_NAMESPACE::Semaphore semaphore VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
+                                              VULKAN_HPP_NAMESPACE::Fence fence         VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
+                                              Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result getGroupPresentCapabilitiesKHR(
+      VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR * pDeviceGroupPresentCapabilities,
+      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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
+      typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR>::type
+      getGroupPresentCapabilitiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result getGroupSurfacePresentModesKHR(
+      VULKAN_HPP_NAMESPACE::SurfaceKHR                       surface,
+      VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR * pModes,
+      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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
+      typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR>::type
+      getGroupSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
+                                      Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      acquireNextImage2KHR( const VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR * pAcquireInfo,
+                            uint32_t *                                            pImageIndex,
+                            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>
+    VULKAN_HPP_NODISCARD ResultValue<uint32_t>
+                         acquireNextImage2KHR( const AcquireNextImageInfoKHR & acquireInfo,
+                                               Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    //=== VK_KHR_display_swapchain ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result createSharedSwapchainsKHR(
+      uint32_t                                             swapchainCount,
+      const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR * pCreateInfos,
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *    pAllocator,
+      VULKAN_HPP_NAMESPACE::SwapchainKHR *                 pSwapchains,
+      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename SwapchainKHRAllocator = std::allocator<SwapchainKHR>,
+              typename Dispatch              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
+      typename ResultValueType<std::vector<SwapchainKHR, SwapchainKHRAllocator>>::type
+      createSharedSwapchainsKHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
+                                 Optional<const AllocationCallbacks> allocator
+                                                    VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <typename SwapchainKHRAllocator = std::allocator<SwapchainKHR>,
+              typename Dispatch              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B                     = SwapchainKHRAllocator,
+              typename std::enable_if<std::is_same<typename B::value_type, SwapchainKHR>::value, int>::type = 0>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
+      typename ResultValueType<std::vector<SwapchainKHR, SwapchainKHRAllocator>>::type
+      createSharedSwapchainsKHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
+                                 Optional<const AllocationCallbacks>                                    allocator,
+                                 SwapchainKHRAllocator & swapchainKHRAllocator,
+                                 Dispatch const & d      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<SwapchainKHR>::type createSharedSwapchainKHR(
+      const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR & createInfo,
+      Optional<const AllocationCallbacks> allocator        VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+      Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template <typename Dispatch              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename SwapchainKHRAllocator = std::allocator<UniqueHandle<SwapchainKHR, Dispatch>>>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
+      typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR, Dispatch>, SwapchainKHRAllocator>>::type
+      createSharedSwapchainsKHRUnique(
+        ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
+        Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+        Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename SwapchainKHRAllocator     = std::allocator<UniqueHandle<SwapchainKHR, Dispatch>>,
+              typename B                         = SwapchainKHRAllocator,
+              typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<SwapchainKHR, Dispatch>>::value,
+                                      int>::type = 0>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
+      typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR, Dispatch>, SwapchainKHRAllocator>>::type
+      createSharedSwapchainsKHRUnique(
+        ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
+        Optional<const AllocationCallbacks>                                    allocator,
+        SwapchainKHRAllocator &                                                swapchainKHRAllocator,
+        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<UniqueHandle<SwapchainKHR, Dispatch>>::type
+      createSharedSwapchainKHRUnique( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR & createInfo,
+                                      Optional<const AllocationCallbacks> allocator
+                                                         VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    //=== VK_EXT_debug_marker ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result debugMarkerSetObjectTagEXT(
+      const VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT * pTagInfo,
+      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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
+      debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT & tagInfo,
+                                  Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result debugMarkerSetObjectNameEXT(
+      const VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT * pNameInfo,
+      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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
+      debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT & nameInfo,
+                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#if defined( VK_ENABLE_BETA_EXTENSIONS )
+    //=== VK_KHR_video_queue ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      createVideoSessionKHR( const VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR * pCreateInfo,
+                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,
+                             VULKAN_HPP_NAMESPACE::VideoSessionKHR *                 pVideoSession,
+                             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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoSessionKHR>::type
+      createVideoSessionKHR( const VideoSessionCreateInfoKHR & createInfo,
+                             Optional<const AllocationCallbacks> allocator
+                                                VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#    ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::VideoSessionKHR, Dispatch>>::type
+      createVideoSessionKHRUnique( const VideoSessionCreateInfoKHR & createInfo,
+                                   Optional<const AllocationCallbacks> allocator
+                                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void
+      destroyVideoSessionKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR             videoSession,
+                              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 destroyVideoSessionKHR(
+      VULKAN_HPP_NAMESPACE::VideoSessionKHR         videoSession,
+      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( VULKAN_HPP_NAMESPACE::VideoSessionKHR             videoSession,
+                  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::VideoSessionKHR         videoSession,
+                  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>
+    VULKAN_HPP_NODISCARD Result getVideoSessionMemoryRequirementsKHR(
+      VULKAN_HPP_NAMESPACE::VideoSessionKHR               videoSession,
+      uint32_t *                                          pVideoSessionMemoryRequirementsCount,
+      VULKAN_HPP_NAMESPACE::VideoGetMemoryPropertiesKHR * pVideoSessionMemoryRequirements,
+      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename VideoGetMemoryPropertiesKHRAllocator = std::allocator<VideoGetMemoryPropertiesKHR>,
+              typename Dispatch                             = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD
+      typename ResultValueType<std::vector<VideoGetMemoryPropertiesKHR, VideoGetMemoryPropertiesKHRAllocator>>::type
+      getVideoSessionMemoryRequirementsKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession,
+                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <
+      typename VideoGetMemoryPropertiesKHRAllocator = std::allocator<VideoGetMemoryPropertiesKHR>,
+      typename Dispatch                             = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+      typename B                                    = VideoGetMemoryPropertiesKHRAllocator,
+      typename std::enable_if<std::is_same<typename B::value_type, VideoGetMemoryPropertiesKHR>::value, int>::type = 0>
+    VULKAN_HPP_NODISCARD
+      typename ResultValueType<std::vector<VideoGetMemoryPropertiesKHR, VideoGetMemoryPropertiesKHRAllocator>>::type
+      getVideoSessionMemoryRequirementsKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR  videoSession,
+                                            VideoGetMemoryPropertiesKHRAllocator & videoGetMemoryPropertiesKHRAllocator,
+                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result bindVideoSessionMemoryKHR(
+      VULKAN_HPP_NAMESPACE::VideoSessionKHR            videoSession,
+      uint32_t                                         videoSessionBindMemoryCount,
+      const VULKAN_HPP_NAMESPACE::VideoBindMemoryKHR * pVideoSessionBindMemories,
+      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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type bindVideoSessionMemoryKHR(
+      VULKAN_HPP_NAMESPACE::VideoSessionKHR                              videoSession,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::VideoBindMemoryKHR> const & videoSessionBindMemories,
+      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result createVideoSessionParametersKHR(
+      const VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR * pCreateInfo,
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                 pAllocator,
+      VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR *                 pVideoSessionParameters,
+      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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
+      typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR>::type
+      createVideoSessionParametersKHR( const VideoSessionParametersCreateInfoKHR & createInfo,
+                                       Optional<const AllocationCallbacks> allocator
+                                                          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#    ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR, Dispatch>>::type
+      createVideoSessionParametersKHRUnique( const VideoSessionParametersCreateInfoKHR & createInfo,
+                                             Optional<const AllocationCallbacks> allocator
+                                                                VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result updateVideoSessionParametersKHR(
+      VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR                   videoSessionParameters,
+      const VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR * pUpdateInfo,
+      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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
+      updateVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters,
+                                       const VideoSessionParametersUpdateInfoKHR &     updateInfo,
+                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void destroyVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR   videoSessionParameters,
+                                           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 destroyVideoSessionParametersKHR(
+      VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters,
+      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( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR   videoSessionParameters,
+                  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::VideoSessionParametersKHR videoSessionParameters,
+                  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*/
+
+    //=== VK_NVX_binary_import ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      createCuModuleNVX( const VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX * pCreateInfo,
+                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
+                         VULKAN_HPP_NAMESPACE::CuModuleNVX *                 pModule,
+                         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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::CuModuleNVX>::type
+      createCuModuleNVX( const CuModuleCreateInfoNVX &                 createInfo,
+                         Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                         Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CuModuleNVX, Dispatch>>::type
+      createCuModuleNVXUnique( const CuModuleCreateInfoNVX & createInfo,
+                               Optional<const AllocationCallbacks> allocator
+                                                  VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      createCuFunctionNVX( const VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX * pCreateInfo,
+                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks *     pAllocator,
+                           VULKAN_HPP_NAMESPACE::CuFunctionNVX *                 pFunction,
+                           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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::CuFunctionNVX>::type
+      createCuFunctionNVX( const CuFunctionCreateInfoNVX &               createInfo,
+                           Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CuFunctionNVX, Dispatch>>::type
+      createCuFunctionNVXUnique( const CuFunctionCreateInfoNVX & createInfo,
+                                 Optional<const AllocationCallbacks> allocator
+                                                    VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void destroyCuModuleNVX( VULKAN_HPP_NAMESPACE::CuModuleNVX                 module,
+                             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
+      destroyCuModuleNVX( VULKAN_HPP_NAMESPACE::CuModuleNVX             module,
+                          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( VULKAN_HPP_NAMESPACE::CuModuleNVX                 module,
+                  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::CuModuleNVX             module,
+                  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 destroyCuFunctionNVX( VULKAN_HPP_NAMESPACE::CuFunctionNVX               function,
+                               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 destroyCuFunctionNVX( VULKAN_HPP_NAMESPACE::CuFunctionNVX function,
+                               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( VULKAN_HPP_NAMESPACE::CuFunctionNVX               function,
+                  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::CuFunctionNVX           function,
+                  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*/
+
+    //=== VK_NVX_image_view_handle ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    uint32_t
+      getImageViewHandleNVX( const VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX * pInfo,
+                             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>
+    uint32_t
+      getImageViewHandleNVX( const ImageViewHandleInfoNVX & info,
+                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      getImageViewAddressNVX( VULKAN_HPP_NAMESPACE::ImageView                       imageView,
+                              VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX * pProperties,
+                              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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
+      typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX>::type
+      getImageViewAddressNVX( VULKAN_HPP_NAMESPACE::ImageView imageView,
+                              Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    //=== VK_AMD_shader_info ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline            pipeline,
+                        VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage,
+                        VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD   infoType,
+                        size_t *                                  pInfoSize,
+                        void *                                    pInfo,
+                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename Uint8_tAllocator = std::allocator<uint8_t>,
+              typename Dispatch         = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
+      getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline            pipeline,
+                        VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage,
+                        VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD   infoType,
+                        Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <typename Uint8_tAllocator = std::allocator<uint8_t>,
+              typename Dispatch         = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B                = Uint8_tAllocator,
+              typename std::enable_if<std::is_same<typename B::value_type, uint8_t>::value, int>::type = 0>
+    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
+      getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline            pipeline,
+                        VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage,
+                        VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD   infoType,
+                        Uint8_tAllocator &                        uint8_tAllocator,
+                        Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#if defined( VK_USE_PLATFORM_WIN32_KHR )
+    //=== VK_NV_external_memory_win32 ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      getMemoryWin32HandleNV( VULKAN_HPP_NAMESPACE::DeviceMemory                    memory,
+                              VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleType,
+                              HANDLE *                                              pHandle,
+                              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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<HANDLE>::type
+      getMemoryWin32HandleNV( VULKAN_HPP_NAMESPACE::DeviceMemory                    memory,
+                              VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleType,
+                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VK_USE_PLATFORM_WIN32_KHR*/
+
+    //=== VK_KHR_device_group ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void getGroupPeerMemoryFeaturesKHR( uint32_t                                       heapIndex,
+                                        uint32_t                                       localDeviceIndex,
+                                        uint32_t                                       remoteDeviceIndex,
+                                        VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags * pPeerMemoryFeatures,
+                                        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>
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags getGroupPeerMemoryFeaturesKHR(
+      uint32_t           heapIndex,
+      uint32_t           localDeviceIndex,
+      uint32_t           remoteDeviceIndex,
+      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    //=== VK_KHR_maintenance1 ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void trimCommandPoolKHR( VULKAN_HPP_NAMESPACE::CommandPool          commandPool,
+                             VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags,
+                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+#if defined( VK_USE_PLATFORM_WIN32_KHR )
+    //=== VK_KHR_external_memory_win32 ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      getMemoryWin32HandleKHR( const VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR * pGetWin32HandleInfo,
+                               HANDLE *                                                  pHandle,
+                               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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<HANDLE>::type
+      getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR & getWin32HandleInfo,
+                               Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result getMemoryWin32HandlePropertiesKHR(
+      VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
+      HANDLE                                                 handle,
+      VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR * pMemoryWin32HandleProperties,
+      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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
+      typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR>::type
+      getMemoryWin32HandlePropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
+                                         HANDLE                                                 handle,
+                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VK_USE_PLATFORM_WIN32_KHR*/
+
+    //=== VK_KHR_external_memory_fd ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      getMemoryFdKHR( const VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR * pGetFdInfo,
+                      int *                                            pFd,
+                      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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<int>::type
+      getMemoryFdKHR( const MemoryGetFdInfoKHR & getFdInfo,
+                      Dispatch const & d         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      getMemoryFdPropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
+                                int                                                    fd,
+                                VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR *          pMemoryFdProperties,
+                                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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR>::type
+      getMemoryFdPropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
+                                int                                                    fd,
+                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#if defined( VK_USE_PLATFORM_WIN32_KHR )
+    //=== VK_KHR_external_semaphore_win32 ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result importSemaphoreWin32HandleKHR(
+      const VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR * pImportSemaphoreWin32HandleInfo,
+      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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
+      importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo,
+                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result getSemaphoreWin32HandleKHR(
+      const VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR * pGetWin32HandleInfo,
+      HANDLE *                                                     pHandle,
+      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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<HANDLE>::type
+      getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo,
+                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VK_USE_PLATFORM_WIN32_KHR*/
+
+    //=== VK_KHR_external_semaphore_fd ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      importSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR * pImportSemaphoreFdInfo,
+                            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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
+      importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo,
+                            Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      getSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR * pGetFdInfo,
+                         int *                                               pFd,
+                         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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<int>::type
+      getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR & getFdInfo,
+                         Dispatch const & d            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    //=== VK_KHR_descriptor_update_template ===
+
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD Result createDescriptorUpdateTemplateKHR(
       const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo * pCreateInfo,
@@ -59390,111 +61244,841 @@ namespace VULKAN_HPP_NAMESPACE
 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      createEvent( const VULKAN_HPP_NAMESPACE::EventCreateInfo *     pCreateInfo,
-                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                   VULKAN_HPP_NAMESPACE::Event *                     pEvent,
-                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+    void destroyDescriptorUpdateTemplateKHR( 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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::Event>::type
-      createEvent( const EventCreateInfo &                       createInfo,
-                   Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                   Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    void destroyDescriptorUpdateTemplateKHR(
+      VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
+      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 updateDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorSet            descriptorSet,
+                                             VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
+                                             const void *                                   pData,
+                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
+      VULKAN_HPP_NOEXCEPT;
+
+    //=== VK_EXT_display_control ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      displayPowerControlEXT( VULKAN_HPP_NAMESPACE::DisplayKHR                  display,
+                              const VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT * pDisplayPowerInfo,
+                              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>
+    typename ResultValueType<void>::type
+      displayPowerControlEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display,
+                              const DisplayPowerInfoEXT &      displayPowerInfo,
+                              Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      registerEventEXT( const VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT *  pDeviceEventInfo,
+                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                        VULKAN_HPP_NAMESPACE::Fence *                     pFence,
+                        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>
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::Fence>::type
+      registerEventEXT( const DeviceEventInfoEXT &                    deviceEventInfo,
+                        Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                        Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Event, Dispatch>>::type
-      createEventUnique( const EventCreateInfo &                       createInfo,
-                         Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                         Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>>::type
+      registerEventEXTUnique( const DeviceEventInfoEXT & deviceEventInfo,
+                              Optional<const AllocationCallbacks> allocator
+                                                 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD Result
-      createFence( const VULKAN_HPP_NAMESPACE::FenceCreateInfo *     pCreateInfo,
-                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                   VULKAN_HPP_NAMESPACE::Fence *                     pFence,
-                   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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::Fence>::type
-      createFence( const FenceCreateInfo &                       createInfo,
-                   Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                   Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>>::type
-      createFenceUnique( const FenceCreateInfo &                       createInfo,
-                         Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                         Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      createFramebuffer( const VULKAN_HPP_NAMESPACE::FramebufferCreateInfo * pCreateInfo,
-                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
-                         VULKAN_HPP_NAMESPACE::Framebuffer *                 pFramebuffer,
-                         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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::Framebuffer>::type
-      createFramebuffer( const FramebufferCreateInfo &                 createInfo,
-                         Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                         Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Framebuffer, Dispatch>>::type
-      createFramebufferUnique( const FramebufferCreateInfo & createInfo,
-                               Optional<const AllocationCallbacks> allocator
-                                                  VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      createGraphicsPipelines( VULKAN_HPP_NAMESPACE::PipelineCache                      pipelineCache,
-                               uint32_t                                                 createInfoCount,
-                               const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo * pCreateInfos,
-                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks *        pAllocator,
-                               VULKAN_HPP_NAMESPACE::Pipeline *                         pPipelines,
+      registerDisplayEventEXT( VULKAN_HPP_NAMESPACE::DisplayKHR                  display,
+                               const VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT * pDisplayEventInfo,
+                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                               VULKAN_HPP_NAMESPACE::Fence *                     pFence,
                                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>
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::Fence>::type registerDisplayEventEXT(
+      VULKAN_HPP_NAMESPACE::DisplayKHR              display,
+      const DisplayEventInfoEXT &                   displayEventInfo,
+      Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+      Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>>::type
+      registerDisplayEventEXTUnique( VULKAN_HPP_NAMESPACE::DisplayKHR display,
+                                     const DisplayEventInfoEXT &      displayEventInfo,
+                                     Optional<const AllocationCallbacks> allocator
+                                                        VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      getSwapchainCounterEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR              swapchain,
+                              VULKAN_HPP_NAMESPACE::SurfaceCounterFlagBitsEXT counter,
+                              uint64_t *                                      pCounterValue,
+                              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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<uint64_t>::type
+      getSwapchainCounterEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR              swapchain,
+                              VULKAN_HPP_NAMESPACE::SurfaceCounterFlagBitsEXT counter,
+                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    //=== VK_GOOGLE_display_timing ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result getRefreshCycleDurationGOOGLE(
+      VULKAN_HPP_NAMESPACE::SwapchainKHR                 swapchain,
+      VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE * pDisplayTimingProperties,
+      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
+      typename ResultValueType<VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE>::type
+      getRefreshCycleDurationGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
+                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result getPastPresentationTimingGOOGLE(
+      VULKAN_HPP_NAMESPACE::SwapchainKHR                   swapchain,
+      uint32_t *                                           pPresentationTimingCount,
+      VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE * pPresentationTimings,
+      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename PastPresentationTimingGOOGLEAllocator = std::allocator<PastPresentationTimingGOOGLE>,
+              typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD
+      typename ResultValueType<std::vector<PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator>>::type
+      getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
+                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <
+      typename PastPresentationTimingGOOGLEAllocator = std::allocator<PastPresentationTimingGOOGLE>,
+      typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+      typename B                                     = PastPresentationTimingGOOGLEAllocator,
+      typename std::enable_if<std::is_same<typename B::value_type, PastPresentationTimingGOOGLE>::value, int>::type = 0>
+    VULKAN_HPP_NODISCARD
+      typename ResultValueType<std::vector<PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator>>::type
+      getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR      swapchain,
+                                       PastPresentationTimingGOOGLEAllocator & pastPresentationTimingGOOGLEAllocator,
+                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    //=== VK_EXT_hdr_metadata ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void setHdrMetadataEXT( uint32_t                                     swapchainCount,
+                            const VULKAN_HPP_NAMESPACE::SwapchainKHR *   pSwapchains,
+                            const VULKAN_HPP_NAMESPACE::HdrMetadataEXT * pMetadata,
+                            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 setHdrMetadataEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainKHR> const &   swapchains,
+                            ArrayProxy<const VULKAN_HPP_NAMESPACE::HdrMetadataEXT> const & metadata,
+                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
+      VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    //=== VK_KHR_create_renderpass2 ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      createRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 * pCreateInfo,
+                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
+                            VULKAN_HPP_NAMESPACE::RenderPass *                  pRenderPass,
+                            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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::RenderPass>::type
+      createRenderPass2KHR( const RenderPassCreateInfo2 & createInfo,
+                            Optional<const AllocationCallbacks> allocator
+                                               VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type
+      createRenderPass2KHRUnique( const RenderPassCreateInfo2 & createInfo,
+                                  Optional<const AllocationCallbacks> allocator
+                                                     VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    //=== VK_KHR_shared_presentable_image ===
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      getSwapchainStatusKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
+                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#else
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result getSwapchainStatusKHR(
+      VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#if defined( VK_USE_PLATFORM_WIN32_KHR )
+    //=== VK_KHR_external_fence_win32 ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result importFenceWin32HandleKHR(
+      const VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR * pImportFenceWin32HandleInfo,
+      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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
+      importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo,
+                                 Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      getFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR * pGetWin32HandleInfo,
+                              HANDLE *                                                 pHandle,
+                              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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<HANDLE>::type
+      getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR & getWin32HandleInfo,
+                              Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VK_USE_PLATFORM_WIN32_KHR*/
+
+    //=== VK_KHR_external_fence_fd ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      importFenceFdKHR( const VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR * pImportFenceFdInfo,
+                        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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
+      importFenceFdKHR( const ImportFenceFdInfoKHR & importFenceFdInfo,
+                        Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      getFenceFdKHR( const VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR * pGetFdInfo,
+                     int *                                           pFd,
+                     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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<int>::type
+      getFenceFdKHR( const FenceGetFdInfoKHR & getFdInfo,
+                     Dispatch const & d        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    //=== VK_KHR_performance_query ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      acquireProfilingLockKHR( const VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR * pInfo,
+                               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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
+      acquireProfilingLockKHR( const AcquireProfilingLockInfoKHR & info,
+                               Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void
+      releaseProfilingLockKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+    //=== VK_EXT_debug_utils ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result setDebugUtilsObjectNameEXT(
+      const VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT * pNameInfo,
+      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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
+      setDebugUtilsObjectNameEXT( const DebugUtilsObjectNameInfoEXT & nameInfo,
+                                  Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result setDebugUtilsObjectTagEXT(
+      const VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT * pTagInfo,
+      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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
+      setDebugUtilsObjectTagEXT( const DebugUtilsObjectTagInfoEXT & tagInfo,
+                                 Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#if defined( VK_USE_PLATFORM_ANDROID_KHR )
+    //=== VK_ANDROID_external_memory_android_hardware_buffer ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result getAndroidHardwareBufferPropertiesANDROID(
+      const struct AHardwareBuffer *                                 buffer,
+      VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID * pProperties,
+      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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
+      typename ResultValueType<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID>::type
+      getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer,
+                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<StructureChain<X, Y, Z...>>::type
+      getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer,
+                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result getMemoryAndroidHardwareBufferANDROID(
+      const VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID * pInfo,
+      struct AHardwareBuffer **                                               pBuffer,
+      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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<struct AHardwareBuffer *>::type
+      getMemoryAndroidHardwareBufferANDROID( const MemoryGetAndroidHardwareBufferInfoANDROID & info,
+                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VK_USE_PLATFORM_ANDROID_KHR*/
+
+    //=== VK_KHR_get_memory_requirements2 ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void getImageMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 * pInfo,
+                                         VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                pMemoryRequirements,
+                                         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>
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getImageMemoryRequirements2KHR(
+      const ImageMemoryRequirementsInfo2 & info,
+      Dispatch const & d                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getImageMemoryRequirements2KHR(
+      const ImageMemoryRequirementsInfo2 & info,
+      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 getBufferMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 * pInfo,
+                                          VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements,
+                                          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>
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getBufferMemoryRequirements2KHR(
+      const BufferMemoryRequirementsInfo2 & info,
+      Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getBufferMemoryRequirements2KHR(
+      const BufferMemoryRequirementsInfo2 & info,
+      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 getImageSparseMemoryRequirements2KHR(
+      const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 * pInfo,
+      uint32_t *                                                       pSparseMemoryRequirementCount,
+      VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 *           pSparseMemoryRequirements,
+      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename SparseImageMemoryRequirements2Allocator = std::allocator<SparseImageMemoryRequirements2>,
+              typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
+                         getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info,
+                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <typename SparseImageMemoryRequirements2Allocator = std::allocator<SparseImageMemoryRequirements2>,
+              typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B                                       = SparseImageMemoryRequirements2Allocator,
+              typename std::enable_if<std::is_same<typename B::value_type, SparseImageMemoryRequirements2>::value,
+                                      int>::type               = 0>
+    VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
+                         getImageSparseMemoryRequirements2KHR(
+                           const ImageSparseMemoryRequirementsInfo2 & info,
+                           SparseImageMemoryRequirements2Allocator &  sparseImageMemoryRequirements2Allocator,
+                           Dispatch const & d                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    //=== VK_KHR_acceleration_structure ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result createAccelerationStructureKHR(
+      const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR * pCreateInfo,
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                pAllocator,
+      VULKAN_HPP_NAMESPACE::AccelerationStructureKHR *                 pAccelerationStructure,
+      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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
+      typename ResultValueType<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR>::type
+      createAccelerationStructureKHR( const AccelerationStructureCreateInfoKHR & createInfo,
+                                      Optional<const AllocationCallbacks> allocator
+                                                         VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR, Dispatch>>::type
+      createAccelerationStructureKHRUnique( const AccelerationStructureCreateInfoKHR & createInfo,
+                                            Optional<const AllocationCallbacks> allocator
+                                                               VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void destroyAccelerationStructureKHR( 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 destroyAccelerationStructureKHR(
+      VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
+      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( 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>
+    VULKAN_HPP_NODISCARD Result buildAccelerationStructuresKHR(
+      VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                   deferredOperation,
+      uint32_t                                                                     infoCount,
+      const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR *      pInfos,
+      const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos,
+      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>
+    Result buildAccelerationStructuresKHR(
+      VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                                     deferredOperation,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const &      infos,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos,
+      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result copyAccelerationStructureKHR(
+      VULKAN_HPP_NAMESPACE::DeferredOperationKHR                     deferredOperation,
+      const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR * pInfo,
+      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>
+    VULKAN_HPP_NODISCARD Result
+      copyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
+                                    const CopyAccelerationStructureInfoKHR &   info,
+                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result copyAccelerationStructureToMemoryKHR(
+      VULKAN_HPP_NAMESPACE::DeferredOperationKHR                             deferredOperation,
+      const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR * pInfo,
+      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>
+    VULKAN_HPP_NODISCARD Result
+      copyAccelerationStructureToMemoryKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR       deferredOperation,
+                                            const CopyAccelerationStructureToMemoryInfoKHR & info,
+                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result copyMemoryToAccelerationStructureKHR(
+      VULKAN_HPP_NAMESPACE::DeferredOperationKHR                             deferredOperation,
+      const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR * pInfo,
+      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>
+    VULKAN_HPP_NODISCARD Result
+      copyMemoryToAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR       deferredOperation,
+                                            const CopyMemoryToAccelerationStructureInfoKHR & info,
+                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result writeAccelerationStructuresPropertiesKHR(
+      uint32_t                                               accelerationStructureCount,
+      const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR * pAccelerationStructures,
+      VULKAN_HPP_NAMESPACE::QueryType                        queryType,
+      size_t                                                 dataSize,
+      void *                                                 pData,
+      size_t                                                 stride,
+      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
+      writeAccelerationStructuresPropertiesKHR(
+        ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
+        VULKAN_HPP_NAMESPACE::QueryType                                          queryType,
+        ArrayProxy<T> const &                                                    data,
+        size_t                                                                   stride,
+        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <typename T,
+              typename Allocator = std::allocator<T>,
+              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<std::vector<T, Allocator>>::type
+      writeAccelerationStructuresPropertiesKHR(
+        ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
+        VULKAN_HPP_NAMESPACE::QueryType                                          queryType,
+        size_t                                                                   dataSize,
+        size_t                                                                   stride,
+        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<T>::type writeAccelerationStructuresPropertyKHR(
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
+      VULKAN_HPP_NAMESPACE::QueryType                                          queryType,
+      size_t                                                                   stride,
+      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    DeviceAddress getAccelerationStructureAddressKHR(
+      const VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR * pInfo,
+      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>
+    DeviceAddress getAccelerationStructureAddressKHR(
+      const AccelerationStructureDeviceAddressInfoKHR & info,
+      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 getAccelerationStructureCompatibilityKHR(
+      const VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR * pVersionInfo,
+      VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR *     pCompatibility,
+      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>
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR
+      getAccelerationStructureCompatibilityKHR( const AccelerationStructureVersionInfoKHR & versionInfo,
+                                                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 getAccelerationStructureBuildSizesKHR(
+      VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR                 buildType,
+      const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR * pBuildInfo,
+      const uint32_t *                                                        pMaxPrimitiveCounts,
+      VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR *          pSizeInfo,
+      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>
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR
+                         getAccelerationStructureBuildSizesKHR(
+                           VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType,
+                           const AccelerationStructureBuildGeometryInfoKHR &       buildInfo,
+                           ArrayProxy<const uint32_t> const & maxPrimitiveCounts   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    //=== VK_KHR_sampler_ycbcr_conversion ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result createSamplerYcbcrConversionKHR(
+      const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo * pCreateInfo,
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *              pAllocator,
+      VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion *                 pYcbcrConversion,
+      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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>::type
+      createSamplerYcbcrConversionKHR( const SamplerYcbcrConversionCreateInfo & createInfo,
+                                       Optional<const AllocationCallbacks> allocator
+                                                          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, Dispatch>>::type
+      createSamplerYcbcrConversionKHRUnique( const SamplerYcbcrConversionCreateInfo & createInfo,
+                                             Optional<const AllocationCallbacks> allocator
+                                                                VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#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,
+                                           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 destroySamplerYcbcrConversionKHR(
+      VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
+      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*/
+
+    //=== VK_KHR_bind_memory2 ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      bindBufferMemory2KHR( uint32_t                                           bindInfoCount,
+                            const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo * pBindInfos,
+                            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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
+      bindBufferMemory2KHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos,
+                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      bindImageMemory2KHR( uint32_t                                          bindInfoCount,
+                           const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo * pBindInfos,
+                           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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
+      bindImageMemory2KHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos,
+                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    //=== VK_EXT_image_drm_format_modifier ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result getImageDrmFormatModifierPropertiesEXT(
+      VULKAN_HPP_NAMESPACE::Image                                 image,
+      VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT * pProperties,
+      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>
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT>::type
+      getImageDrmFormatModifierPropertiesEXT( VULKAN_HPP_NAMESPACE::Image image,
+                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    //=== VK_EXT_validation_cache ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      createValidationCacheEXT( const VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT * pCreateInfo,
+                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks *          pAllocator,
+                                VULKAN_HPP_NAMESPACE::ValidationCacheEXT *                 pValidationCache,
+                                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>
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::ValidationCacheEXT>::type createValidationCacheEXT(
+      const ValidationCacheCreateInfoEXT &          createInfo,
+      Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+      Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ValidationCacheEXT, Dispatch>>::type
+      createValidationCacheEXTUnique( const ValidationCacheCreateInfoEXT & createInfo,
+                                      Optional<const AllocationCallbacks> allocator
+                                                         VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void destroyValidationCacheEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT          validationCache,
+                                    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 destroyValidationCacheEXT(
+      VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
+      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( VULKAN_HPP_NAMESPACE::ValidationCacheEXT          validationCache,
+                  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::ValidationCacheEXT      validationCache,
+                  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>
+    VULKAN_HPP_NODISCARD Result
+      mergeValidationCachesEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT         dstCache,
+                                uint32_t                                         srcCacheCount,
+                                const VULKAN_HPP_NAMESPACE::ValidationCacheEXT * pSrcCaches,
+                                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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
+      mergeValidationCachesEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT                           dstCache,
+                                ArrayProxy<const VULKAN_HPP_NAMESPACE::ValidationCacheEXT> const & srcCaches,
+                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result getValidationCacheDataEXT(
+      VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache,
+      size_t *                                 pDataSize,
+      void *                                   pData,
+      Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename Uint8_tAllocator = std::allocator<uint8_t>,
+              typename Dispatch         = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
+      getValidationCacheDataEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache,
+                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <typename Uint8_tAllocator = std::allocator<uint8_t>,
+              typename Dispatch         = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B                = Uint8_tAllocator,
+              typename std::enable_if<std::is_same<typename B::value_type, uint8_t>::value, int>::type = 0>
+    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
+      getValidationCacheDataEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache,
+                                 Uint8_tAllocator &                       uint8_tAllocator,
+                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    //=== VK_NV_ray_tracing ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result createAccelerationStructureNV(
+      const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV * pCreateInfo,
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *               pAllocator,
+      VULKAN_HPP_NAMESPACE::AccelerationStructureNV *                 pAccelerationStructure,
+      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>
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::AccelerationStructureNV>::type createAccelerationStructureNV(
+      const AccelerationStructureCreateInfoNV &     createInfo,
+      Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+      Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::AccelerationStructureNV, Dispatch>>::type
+      createAccelerationStructureNVUnique( const AccelerationStructureCreateInfoNV & createInfo,
+                                           Optional<const AllocationCallbacks> allocator
+                                                              VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void destroyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV     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 destroyAccelerationStructureNV(
+      VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
+      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( VULKAN_HPP_NAMESPACE::AccelerationStructureNV     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::AccelerationStructureNV 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 getAccelerationStructureMemoryRequirementsNV(
+      const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV * pInfo,
+      VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR *                              pMemoryRequirements,
+      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>
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR getAccelerationStructureMemoryRequirementsNV(
+      const AccelerationStructureMemoryRequirementsInfoNV & info,
+      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getAccelerationStructureMemoryRequirementsNV(
+      const AccelerationStructureMemoryRequirementsInfoNV & info,
+      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result bindAccelerationStructureMemoryNV(
+      uint32_t                                                            bindInfoCount,
+      const VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV * pBindInfos,
+      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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type bindAccelerationStructureMemoryNV(
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV> const & bindInfos,
+      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result createRayTracingPipelinesNV(
+      VULKAN_HPP_NAMESPACE::PipelineCache                          pipelineCache,
+      uint32_t                                                     createInfoCount,
+      const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV * pCreateInfos,
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *            pAllocator,
+      VULKAN_HPP_NAMESPACE::Pipeline *                             pPipelines,
+      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template <typename PipelineAllocator = std::allocator<Pipeline>,
               typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, PipelineAllocator>> createGraphicsPipelines(
-      VULKAN_HPP_NAMESPACE::PipelineCache                                        pipelineCache,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
+    VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, PipelineAllocator>> createRayTracingPipelinesNV(
+      VULKAN_HPP_NAMESPACE::PipelineCache                                            pipelineCache,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
       Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
       Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename PipelineAllocator = std::allocator<Pipeline>,
               typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
               typename B                 = PipelineAllocator,
               typename std::enable_if<std::is_same<typename B::value_type, Pipeline>::value, int>::type = 0>
-    VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, PipelineAllocator>>
-                         createGraphicsPipelines( VULKAN_HPP_NAMESPACE::PipelineCache                                        pipelineCache,
-                                                  ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
-                                                  Optional<const AllocationCallbacks>                                        allocator,
-                                                  PipelineAllocator & pipelineAllocator,
-                                                  Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, PipelineAllocator>> createRayTracingPipelinesNV(
+      VULKAN_HPP_NAMESPACE::PipelineCache                                            pipelineCache,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
+      Optional<const AllocationCallbacks>                                            allocator,
+      PipelineAllocator &                                                            pipelineAllocator,
+      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD ResultValue<Pipeline> createGraphicsPipeline(
-      VULKAN_HPP_NAMESPACE::PipelineCache                      pipelineCache,
-      const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo & createInfo,
-      Optional<const AllocationCallbacks> allocator            VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-      Dispatch const & d                                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    VULKAN_HPP_NODISCARD ResultValue<Pipeline> createRayTracingPipelineNV(
+      VULKAN_HPP_NAMESPACE::PipelineCache                          pipelineCache,
+      const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV & createInfo,
+      Optional<const AllocationCallbacks> allocator                VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+      Dispatch const & d                                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
     template <typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
               typename PipelineAllocator = std::allocator<UniqueHandle<Pipeline, Dispatch>>>
     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
-                         createGraphicsPipelinesUnique(
-                           VULKAN_HPP_NAMESPACE::PipelineCache                                        pipelineCache,
-                           ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
+                         createRayTracingPipelinesNVUnique(
+                           VULKAN_HPP_NAMESPACE::PipelineCache                                            pipelineCache,
+                           ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
                            Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
                            Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
@@ -59503,65 +62087,553 @@ namespace VULKAN_HPP_NAMESPACE
               typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<Pipeline, Dispatch>>::value,
                                       int>::type = 0>
     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
-                         createGraphicsPipelinesUnique(
-                           VULKAN_HPP_NAMESPACE::PipelineCache                                        pipelineCache,
-                           ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
-                           Optional<const AllocationCallbacks>                                        allocator,
-                           PipelineAllocator &                                                        pipelineAllocator,
+                         createRayTracingPipelinesNVUnique(
+                           VULKAN_HPP_NAMESPACE::PipelineCache                                            pipelineCache,
+                           ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
+                           Optional<const AllocationCallbacks>                                            allocator,
+                           PipelineAllocator &                                                            pipelineAllocator,
                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<Pipeline, Dispatch>> createGraphicsPipelineUnique(
-      VULKAN_HPP_NAMESPACE::PipelineCache                      pipelineCache,
-      const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo & createInfo,
-      Optional<const AllocationCallbacks> allocator            VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-      Dispatch const & d                                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<Pipeline, Dispatch>> createRayTracingPipelineNVUnique(
+      VULKAN_HPP_NAMESPACE::PipelineCache                          pipelineCache,
+      const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV & createInfo,
+      Optional<const AllocationCallbacks> allocator                VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+      Dispatch const & d                                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result getRayTracingShaderGroupHandlesNV(
+      VULKAN_HPP_NAMESPACE::Pipeline pipeline,
+      uint32_t                       firstGroup,
+      uint32_t                       groupCount,
+      size_t                         dataSize,
+      void *                         pData,
+      Dispatch const & d             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
+      getRayTracingShaderGroupHandlesNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
+                                         uint32_t                       firstGroup,
+                                         uint32_t                       groupCount,
+                                         ArrayProxy<T> const &          data,
+                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <typename T,
+              typename Allocator = std::allocator<T>,
+              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<std::vector<T, Allocator>>::type
+      getRayTracingShaderGroupHandlesNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
+                                         uint32_t                       firstGroup,
+                                         uint32_t                       groupCount,
+                                         size_t                         dataSize,
+                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<T>::type
+      getRayTracingShaderGroupHandleNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
+                                        uint32_t                       firstGroup,
+                                        uint32_t                       groupCount,
+                                        Dispatch const & d             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result getAccelerationStructureHandleNV(
+      VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
+      size_t                                        dataSize,
+      void *                                        pData,
+      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
+      getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
+                                        ArrayProxy<T> const &                         data,
+                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <typename T,
+              typename Allocator = std::allocator<T>,
+              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<std::vector<T, Allocator>>::type
+      getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
+                                        size_t                                        dataSize,
+                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<T>::type
+      getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
+                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD Result
-      createImage( const VULKAN_HPP_NAMESPACE::ImageCreateInfo *     pCreateInfo,
-                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                   VULKAN_HPP_NAMESPACE::Image *                     pImage,
-                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+      compileDeferredNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
+                         uint32_t                       shader,
+                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#else
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
+      compileDeferredNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
+                         uint32_t                       shader,
+                         Dispatch const & d             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    //=== VK_KHR_maintenance3 ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void getDescriptorSetLayoutSupportKHR( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo * pCreateInfo,
+                                           VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport *          pSupport,
+                                           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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::Image>::type
-      createImage( const ImageCreateInfo &                       createInfo,
-                   Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                   Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport getDescriptorSetLayoutSupportKHR(
+      const DescriptorSetLayoutCreateInfo & createInfo,
+      Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getDescriptorSetLayoutSupportKHR(
+      const DescriptorSetLayoutCreateInfo & createInfo,
+      Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    //=== VK_EXT_external_memory_host ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result getMemoryHostPointerPropertiesEXT(
+      VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
+      const void *                                           pHostPointer,
+      VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT * pMemoryHostPointerProperties,
+      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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
+      typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT>::type
+      getMemoryHostPointerPropertiesEXT( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
+                                         const void *                                           pHostPointer,
+                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    //=== VK_EXT_calibrated_timestamps ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result getCalibratedTimestampsEXT(
+      uint32_t                                                 timestampCount,
+      const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT * pTimestampInfos,
+      uint64_t *                                               pTimestamps,
+      uint64_t *                                               pMaxDeviation,
+      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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<uint64_t>::type getCalibratedTimestampsEXT(
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT> const & timestampInfos,
+      ArrayProxy<uint64_t> const &                                               timestamps,
+      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <typename Uint64_tAllocator = std::allocator<uint64_t>,
+              typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
+      typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type
+      getCalibratedTimestampsEXT(
+        ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT> const & timestampInfos,
+        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <typename Uint64_tAllocator = std::allocator<uint64_t>,
+              typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B                 = Uint64_tAllocator,
+              typename std::enable_if<std::is_same<typename B::value_type, uint64_t>::value, int>::type = 0>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
+      typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type
+      getCalibratedTimestampsEXT(
+        ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT> const & timestampInfos,
+        Uint64_tAllocator &                                                        uint64_tAllocator,
+        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    //=== VK_KHR_timeline_semaphore ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result getSemaphoreCounterValueKHR(
+      VULKAN_HPP_NAMESPACE::Semaphore semaphore,
+      uint64_t *                      pValue,
+      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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<uint64_t>::type
+      getSemaphoreCounterValueKHR( VULKAN_HPP_NAMESPACE::Semaphore semaphore,
+                                   Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      waitSemaphoresKHR( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo * pWaitInfo,
+                         uint64_t                                        timeout,
+                         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>
+    VULKAN_HPP_NODISCARD Result waitSemaphoresKHR( const SemaphoreWaitInfo & waitInfo,
+                                                   uint64_t                  timeout,
+                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      signalSemaphoreKHR( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo * pSignalInfo,
+                          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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
+      signalSemaphoreKHR( const SemaphoreSignalInfo & signalInfo,
+                          Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    //=== VK_INTEL_performance_query ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result initializePerformanceApiINTEL(
+      const VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL * pInitializeInfo,
+      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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
+      initializePerformanceApiINTEL( const InitializePerformanceApiInfoINTEL & initializeInfo,
+                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void uninitializePerformanceApiINTEL( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
+      VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result acquirePerformanceConfigurationINTEL(
+      const VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL * pAcquireInfo,
+      VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL *                  pConfiguration,
+      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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
+      typename ResultValueType<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL>::type
+      acquirePerformanceConfigurationINTEL( const PerformanceConfigurationAcquireInfoINTEL & acquireInfo,
+                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Image, Dispatch>>::type
-      createImageUnique( const ImageCreateInfo &                       createInfo,
-                         Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                         Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL, Dispatch>>::type
+      acquirePerformanceConfigurationINTELUnique( const PerformanceConfigurationAcquireInfoINTEL & acquireInfo,
+                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result releasePerformanceConfigurationINTEL(
+      VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,
+      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#else
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type releasePerformanceConfigurationINTEL(
+      VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
+      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      release( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,
+               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#else
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
+      release( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,
+               Dispatch const & d                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result getPerformanceParameterINTEL(
+      VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL parameter,
+      VULKAN_HPP_NAMESPACE::PerformanceValueINTEL *       pValue,
+      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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::PerformanceValueINTEL>::type
+      getPerformanceParameterINTEL( VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL parameter,
+                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    //=== VK_AMD_display_native_hdr ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void setLocalDimmingAMD( VULKAN_HPP_NAMESPACE::SwapchainKHR swapChain,
+                             VULKAN_HPP_NAMESPACE::Bool32       localDimmingEnable,
+                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+    //=== VK_EXT_buffer_device_address ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    DeviceAddress
+      getBufferAddressEXT( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,
+                           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>
+    DeviceAddress
+      getBufferAddressEXT( const BufferDeviceAddressInfo & info,
+                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#if defined( VK_USE_PLATFORM_WIN32_KHR )
+    //=== VK_EXT_full_screen_exclusive ===
+
+#  ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result acquireFullScreenExclusiveModeEXT(
+      VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
+      Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#  else
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
+      acquireFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
+                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#  ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result releaseFullScreenExclusiveModeEXT(
+      VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
+      Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#  else
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
+         releaseFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
+                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result getGroupSurfacePresentModes2EXT(
+      const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
+      VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR *      pModes,
+      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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
+      typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR>::type
+      getGroupSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
+                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VK_USE_PLATFORM_WIN32_KHR*/
+
+    //=== VK_KHR_buffer_device_address ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    DeviceAddress
+      getBufferAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,
+                           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>
+    DeviceAddress
+      getBufferAddressKHR( const BufferDeviceAddressInfo & info,
+                           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>
+    uint64_t getBufferOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,
+                                               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>
+    uint64_t getBufferOpaqueCaptureAddressKHR( const BufferDeviceAddressInfo & info,
+                                               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>
+    uint64_t getMemoryOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo * pInfo,
+                                               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>
+    uint64_t getMemoryOpaqueCaptureAddressKHR( const DeviceMemoryOpaqueCaptureAddressInfo & info,
+                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
+      VULKAN_HPP_NOEXCEPT;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    //=== VK_EXT_host_query_reset ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void resetQueryPoolEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
+                            uint32_t                        firstQuery,
+                            uint32_t                        queryCount,
+                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+    //=== VK_KHR_deferred_host_operations ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result createDeferredOperationKHR(
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+      VULKAN_HPP_NAMESPACE::DeferredOperationKHR *      pDeferredOperation,
+      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>
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::DeferredOperationKHR>::type createDeferredOperationKHR(
+      Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+      Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DeferredOperationKHR, Dispatch>>::type
+      createDeferredOperationKHRUnique( Optional<const AllocationCallbacks> allocator
+                                                           VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      createImageView( const VULKAN_HPP_NAMESPACE::ImageViewCreateInfo * pCreateInfo,
-                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                       VULKAN_HPP_NAMESPACE::ImageView *                 pView,
-                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+    void destroyDeferredOperationKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR        operation,
+                                      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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageView>::type
-      createImageView( const ImageViewCreateInfo &                   createInfo,
-                       Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                       Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+    void destroyDeferredOperationKHR(
+      VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
+      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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ImageView, Dispatch>>::type
-      createImageViewUnique( const ImageViewCreateInfo & createInfo,
-                             Optional<const AllocationCallbacks> allocator
-                                                VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+    void destroy( VULKAN_HPP_NAMESPACE::DeferredOperationKHR        operation,
+                  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::DeferredOperationKHR    operation,
+                  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>
+    uint32_t getDeferredOperationMaxConcurrencyKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
+                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
+      VULKAN_HPP_NOEXCEPT;
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result getDeferredOperationResultKHR(
+      VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
+      Dispatch const & d                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#else
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      getDeferredOperationResultKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
+                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      deferredOperationJoinKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
+                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#else
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      deferredOperationJoinKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
+                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    //=== VK_KHR_pipeline_executable_properties ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result getPipelineExecutablePropertiesKHR(
+      const VULKAN_HPP_NAMESPACE::PipelineInfoKHR *           pPipelineInfo,
+      uint32_t *                                              pExecutableCount,
+      VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR * pProperties,
+      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename PipelineExecutablePropertiesKHRAllocator = std::allocator<PipelineExecutablePropertiesKHR>,
+              typename Dispatch                                 = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD typename ResultValueType<
+      std::vector<PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator>>::type
+      getPipelineExecutablePropertiesKHR( const PipelineInfoKHR & pipelineInfo,
+                                          Dispatch const & d      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <typename PipelineExecutablePropertiesKHRAllocator = std::allocator<PipelineExecutablePropertiesKHR>,
+              typename Dispatch                                 = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B                                        = PipelineExecutablePropertiesKHRAllocator,
+              typename std::enable_if<std::is_same<typename B::value_type, PipelineExecutablePropertiesKHR>::value,
+                                      int>::type                = 0>
+    VULKAN_HPP_NODISCARD typename ResultValueType<
+      std::vector<PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator>>::type
+      getPipelineExecutablePropertiesKHR(
+        const PipelineInfoKHR &                    pipelineInfo,
+        PipelineExecutablePropertiesKHRAllocator & pipelineExecutablePropertiesKHRAllocator,
+        Dispatch const & d                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result getPipelineExecutableStatisticsKHR(
+      const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR * pExecutableInfo,
+      uint32_t *                                              pStatisticCount,
+      VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR *  pStatistics,
+      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename PipelineExecutableStatisticKHRAllocator = std::allocator<PipelineExecutableStatisticKHR>,
+              typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD typename ResultValueType<
+      std::vector<PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator>>::type
+      getPipelineExecutableStatisticsKHR( const PipelineExecutableInfoKHR & executableInfo,
+                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <typename PipelineExecutableStatisticKHRAllocator = std::allocator<PipelineExecutableStatisticKHR>,
+              typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B                                       = PipelineExecutableStatisticKHRAllocator,
+              typename std::enable_if<std::is_same<typename B::value_type, PipelineExecutableStatisticKHR>::value,
+                                      int>::type               = 0>
+    VULKAN_HPP_NODISCARD typename ResultValueType<
+      std::vector<PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator>>::type
+      getPipelineExecutableStatisticsKHR(
+        const PipelineExecutableInfoKHR &         executableInfo,
+        PipelineExecutableStatisticKHRAllocator & pipelineExecutableStatisticKHRAllocator,
+        Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result getPipelineExecutableInternalRepresentationsKHR(
+      const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR *             pExecutableInfo,
+      uint32_t *                                                          pInternalRepresentationCount,
+      VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR * pInternalRepresentations,
+      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename PipelineExecutableInternalRepresentationKHRAllocator =
+                std::allocator<PipelineExecutableInternalRepresentationKHR>,
+              typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD
+      typename ResultValueType<std::vector<PipelineExecutableInternalRepresentationKHR,
+                                           PipelineExecutableInternalRepresentationKHRAllocator>>::type
+      getPipelineExecutableInternalRepresentationsKHR( const PipelineExecutableInfoKHR & executableInfo,
+                                                       Dispatch const & d
+                                                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <
+      typename PipelineExecutableInternalRepresentationKHRAllocator =
+        std::allocator<PipelineExecutableInternalRepresentationKHR>,
+      typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+      typename B                         = PipelineExecutableInternalRepresentationKHRAllocator,
+      typename std::enable_if<std::is_same<typename B::value_type, PipelineExecutableInternalRepresentationKHR>::value,
+                              int>::type = 0>
+    VULKAN_HPP_NODISCARD
+      typename ResultValueType<std::vector<PipelineExecutableInternalRepresentationKHR,
+                                           PipelineExecutableInternalRepresentationKHRAllocator>>::type
+      getPipelineExecutableInternalRepresentationsKHR(
+        const PipelineExecutableInfoKHR &                      executableInfo,
+        PipelineExecutableInternalRepresentationKHRAllocator & pipelineExecutableInternalRepresentationKHRAllocator,
+        Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    //=== VK_NV_device_generated_commands ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void getGeneratedCommandsMemoryRequirementsNV(
+      const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV * pInfo,
+      VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                             pMemoryRequirements,
+      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>
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getGeneratedCommandsMemoryRequirementsNV(
+      const GeneratedCommandsMemoryRequirementsInfoNV & info,
+      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getGeneratedCommandsMemoryRequirementsNV(
+      const GeneratedCommandsMemoryRequirementsInfoNV & info,
+      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD Result createIndirectCommandsLayoutNV(
@@ -59589,51 +62661,30 @@ namespace VULKAN_HPP_NAMESPACE
 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      createPipelineCache( const VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo * pCreateInfo,
-                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks *     pAllocator,
-                           VULKAN_HPP_NAMESPACE::PipelineCache *                 pPipelineCache,
-                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+    void destroyIndirectCommandsLayoutNV( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV    indirectCommandsLayout,
+                                          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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::PipelineCache>::type
-      createPipelineCache( const PipelineCacheCreateInfo &               createInfo,
-                           Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineCache, Dispatch>>::type
-      createPipelineCacheUnique( const PipelineCacheCreateInfo & createInfo,
-                                 Optional<const AllocationCallbacks> allocator
-                                                    VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+    void destroyIndirectCommandsLayoutNV(
+      VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
+      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>
-    VULKAN_HPP_NODISCARD Result
-      createPipelineLayout( const VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo * pCreateInfo,
-                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks *      pAllocator,
-                            VULKAN_HPP_NAMESPACE::PipelineLayout *                 pPipelineLayout,
-                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+    void destroy( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV    indirectCommandsLayout,
+                  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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::PipelineLayout>::type
-      createPipelineLayout( const PipelineLayoutCreateInfo & createInfo,
-                            Optional<const AllocationCallbacks> allocator
-                                               VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineLayout, Dispatch>>::type
-      createPipelineLayoutUnique( const PipelineLayoutCreateInfo & createInfo,
-                                  Optional<const AllocationCallbacks> allocator
-                                                     VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+    void destroy( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout,
+                  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*/
+
+    //=== VK_EXT_private_data ===
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD Result
@@ -59658,27 +62709,63 @@ namespace VULKAN_HPP_NAMESPACE
 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      createQueryPool( const VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo * pCreateInfo,
-                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                       VULKAN_HPP_NAMESPACE::QueryPool *                 pQueryPool,
-                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+    void destroyPrivateDataSlotEXT( VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT          privateDataSlot,
+                                    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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::QueryPool>::type
-      createQueryPool( const QueryPoolCreateInfo &                   createInfo,
-                       Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                       Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+    void destroyPrivateDataSlotEXT(
+      VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
+      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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::QueryPool, Dispatch>>::type
-      createQueryPoolUnique( const QueryPoolCreateInfo & createInfo,
-                             Optional<const AllocationCallbacks> allocator
-                                                VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+    void destroy( VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT          privateDataSlot,
+                  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::PrivateDataSlotEXT      privateDataSlot,
+                  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*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType         objectType,
+                         uint64_t                                 objectHandle,
+                         VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot,
+                         uint64_t                                 data,
+                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#else
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    typename ResultValueType<void>::type
+         setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType         objectType,
+                            uint64_t                                 objectHandle,
+                            VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot,
+                            uint64_t                                 data,
+                            Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void getPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType         objectType,
+                            uint64_t                                 objectHandle,
+                            VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot,
+                            uint64_t *                               pData,
+                            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>
+    VULKAN_HPP_NODISCARD uint64_t
+      getPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType         objectType,
+                         uint64_t                                 objectHandle,
+                         VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot,
+                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    //=== VK_KHR_ray_tracing_pipeline ===
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD Result createRayTracingPipelinesKHR(
@@ -59750,2291 +62837,38 @@ namespace VULKAN_HPP_NAMESPACE
 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result createRayTracingPipelinesNV(
-      VULKAN_HPP_NAMESPACE::PipelineCache                          pipelineCache,
-      uint32_t                                                     createInfoCount,
-      const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV * pCreateInfos,
-      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *            pAllocator,
-      VULKAN_HPP_NAMESPACE::Pipeline *                             pPipelines,
-      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename PipelineAllocator = std::allocator<Pipeline>,
-              typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, PipelineAllocator>> createRayTracingPipelinesNV(
-      VULKAN_HPP_NAMESPACE::PipelineCache                                            pipelineCache,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
-      Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-      Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename PipelineAllocator = std::allocator<Pipeline>,
-              typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B                 = PipelineAllocator,
-              typename std::enable_if<std::is_same<typename B::value_type, Pipeline>::value, int>::type = 0>
-    VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, PipelineAllocator>> createRayTracingPipelinesNV(
-      VULKAN_HPP_NAMESPACE::PipelineCache                                            pipelineCache,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
-      Optional<const AllocationCallbacks>                                            allocator,
-      PipelineAllocator &                                                            pipelineAllocator,
-      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD ResultValue<Pipeline> createRayTracingPipelineNV(
-      VULKAN_HPP_NAMESPACE::PipelineCache                          pipelineCache,
-      const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV & createInfo,
-      Optional<const AllocationCallbacks> allocator                VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-      Dispatch const & d                                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename PipelineAllocator = std::allocator<UniqueHandle<Pipeline, Dispatch>>>
-    VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
-                         createRayTracingPipelinesNVUnique(
-                           VULKAN_HPP_NAMESPACE::PipelineCache                                            pipelineCache,
-                           ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
-                           Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                           Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename PipelineAllocator         = std::allocator<UniqueHandle<Pipeline, Dispatch>>,
-              typename B                         = PipelineAllocator,
-              typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<Pipeline, Dispatch>>::value,
-                                      int>::type = 0>
-    VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
-                         createRayTracingPipelinesNVUnique(
-                           VULKAN_HPP_NAMESPACE::PipelineCache                                            pipelineCache,
-                           ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
-                           Optional<const AllocationCallbacks>                                            allocator,
-                           PipelineAllocator &                                                            pipelineAllocator,
-                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<Pipeline, Dispatch>> createRayTracingPipelineNVUnique(
-      VULKAN_HPP_NAMESPACE::PipelineCache                          pipelineCache,
-      const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV & createInfo,
-      Optional<const AllocationCallbacks> allocator                VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-      Dispatch const & d                                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      createRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo * pCreateInfo,
-                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks *  pAllocator,
-                        VULKAN_HPP_NAMESPACE::RenderPass *                 pRenderPass,
-                        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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::RenderPass>::type
-      createRenderPass( const RenderPassCreateInfo &                  createInfo,
-                        Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                        Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type
-      createRenderPassUnique( const RenderPassCreateInfo & createInfo,
-                              Optional<const AllocationCallbacks> allocator
-                                                 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      createRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 * pCreateInfo,
-                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
-                         VULKAN_HPP_NAMESPACE::RenderPass *                  pRenderPass,
-                         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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::RenderPass>::type
-      createRenderPass2( const RenderPassCreateInfo2 &                 createInfo,
-                         Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                         Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type
-      createRenderPass2Unique( const RenderPassCreateInfo2 & createInfo,
-                               Optional<const AllocationCallbacks> allocator
-                                                  VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      createRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 * pCreateInfo,
-                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
-                            VULKAN_HPP_NAMESPACE::RenderPass *                  pRenderPass,
-                            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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::RenderPass>::type
-      createRenderPass2KHR( const RenderPassCreateInfo2 & createInfo,
-                            Optional<const AllocationCallbacks> allocator
-                                               VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type
-      createRenderPass2KHRUnique( const RenderPassCreateInfo2 & createInfo,
-                                  Optional<const AllocationCallbacks> allocator
-                                                     VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      createSampler( const VULKAN_HPP_NAMESPACE::SamplerCreateInfo *   pCreateInfo,
-                     const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                     VULKAN_HPP_NAMESPACE::Sampler *                   pSampler,
-                     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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::Sampler>::type
-      createSampler( const SamplerCreateInfo &                     createInfo,
-                     Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                     Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Sampler, Dispatch>>::type
-      createSamplerUnique( const SamplerCreateInfo &                     createInfo,
-                           Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result createSamplerYcbcrConversion(
-      const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo * pCreateInfo,
-      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *              pAllocator,
-      VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion *                 pYcbcrConversion,
-      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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>::type
-      createSamplerYcbcrConversion( const SamplerYcbcrConversionCreateInfo & createInfo,
-                                    Optional<const AllocationCallbacks> allocator
-                                                       VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, Dispatch>>::type
-      createSamplerYcbcrConversionUnique( const SamplerYcbcrConversionCreateInfo & createInfo,
-                                          Optional<const AllocationCallbacks> allocator
-                                                             VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result createSamplerYcbcrConversionKHR(
-      const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo * pCreateInfo,
-      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *              pAllocator,
-      VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion *                 pYcbcrConversion,
-      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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>::type
-      createSamplerYcbcrConversionKHR( const SamplerYcbcrConversionCreateInfo & createInfo,
-                                       Optional<const AllocationCallbacks> allocator
-                                                          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, Dispatch>>::type
-      createSamplerYcbcrConversionKHRUnique( const SamplerYcbcrConversionCreateInfo & createInfo,
-                                             Optional<const AllocationCallbacks> allocator
-                                                                VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      createSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo * pCreateInfo,
-                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                       VULKAN_HPP_NAMESPACE::Semaphore *                 pSemaphore,
-                       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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::Semaphore>::type
-      createSemaphore( const SemaphoreCreateInfo &                   createInfo,
-                       Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                       Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Semaphore, Dispatch>>::type
-      createSemaphoreUnique( const SemaphoreCreateInfo & createInfo,
-                             Optional<const AllocationCallbacks> allocator
-                                                VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      createShaderModule( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo * pCreateInfo,
-                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks *    pAllocator,
-                          VULKAN_HPP_NAMESPACE::ShaderModule *                 pShaderModule,
-                          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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::ShaderModule>::type
-      createShaderModule( const ShaderModuleCreateInfo &                createInfo,
-                          Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderModule, Dispatch>>::type
-      createShaderModuleUnique( const ShaderModuleCreateInfo & createInfo,
-                                Optional<const AllocationCallbacks> allocator
-                                                   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result createSharedSwapchainsKHR(
-      uint32_t                                             swapchainCount,
-      const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR * pCreateInfos,
-      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *    pAllocator,
-      VULKAN_HPP_NAMESPACE::SwapchainKHR *                 pSwapchains,
-      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename SwapchainKHRAllocator = std::allocator<SwapchainKHR>,
-              typename Dispatch              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
-      typename ResultValueType<std::vector<SwapchainKHR, SwapchainKHRAllocator>>::type
-      createSharedSwapchainsKHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
-                                 Optional<const AllocationCallbacks> allocator
-                                                    VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename SwapchainKHRAllocator = std::allocator<SwapchainKHR>,
-              typename Dispatch              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B                     = SwapchainKHRAllocator,
-              typename std::enable_if<std::is_same<typename B::value_type, SwapchainKHR>::value, int>::type = 0>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
-      typename ResultValueType<std::vector<SwapchainKHR, SwapchainKHRAllocator>>::type
-      createSharedSwapchainsKHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
-                                 Optional<const AllocationCallbacks>                                    allocator,
-                                 SwapchainKHRAllocator & swapchainKHRAllocator,
-                                 Dispatch const & d      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<SwapchainKHR>::type createSharedSwapchainKHR(
-      const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR & createInfo,
-      Optional<const AllocationCallbacks> allocator        VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-      Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Dispatch              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename SwapchainKHRAllocator = std::allocator<UniqueHandle<SwapchainKHR, Dispatch>>>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
-      typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR, Dispatch>, SwapchainKHRAllocator>>::type
-      createSharedSwapchainsKHRUnique(
-        ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
-        Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-        Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename SwapchainKHRAllocator     = std::allocator<UniqueHandle<SwapchainKHR, Dispatch>>,
-              typename B                         = SwapchainKHRAllocator,
-              typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<SwapchainKHR, Dispatch>>::value,
-                                      int>::type = 0>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
-      typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR, Dispatch>, SwapchainKHRAllocator>>::type
-      createSharedSwapchainsKHRUnique(
-        ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
-        Optional<const AllocationCallbacks>                                    allocator,
-        SwapchainKHRAllocator &                                                swapchainKHRAllocator,
-        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<UniqueHandle<SwapchainKHR, Dispatch>>::type
-      createSharedSwapchainKHRUnique( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR & createInfo,
-                                      Optional<const AllocationCallbacks> allocator
-                                                         VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      createSwapchainKHR( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR * pCreateInfo,
-                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks *    pAllocator,
-                          VULKAN_HPP_NAMESPACE::SwapchainKHR *                 pSwapchain,
-                          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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SwapchainKHR>::type
-      createSwapchainKHR( const SwapchainCreateInfoKHR &                createInfo,
-                          Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>::type
-      createSwapchainKHRUnique( const SwapchainCreateInfoKHR & createInfo,
-                                Optional<const AllocationCallbacks> allocator
-                                                   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      createValidationCacheEXT( const VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT * pCreateInfo,
-                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks *          pAllocator,
-                                VULKAN_HPP_NAMESPACE::ValidationCacheEXT *                 pValidationCache,
-                                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>
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::ValidationCacheEXT>::type createValidationCacheEXT(
-      const ValidationCacheCreateInfoEXT &          createInfo,
-      Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-      Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ValidationCacheEXT, Dispatch>>::type
-      createValidationCacheEXTUnique( const ValidationCacheCreateInfoEXT & createInfo,
-                                      Optional<const AllocationCallbacks> allocator
-                                                         VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#if defined( VK_ENABLE_BETA_EXTENSIONS )
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      createVideoSessionKHR( const VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR * pCreateInfo,
-                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,
-                             VULKAN_HPP_NAMESPACE::VideoSessionKHR *                 pVideoSession,
-                             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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoSessionKHR>::type
-      createVideoSessionKHR( const VideoSessionCreateInfoKHR & createInfo,
-                             Optional<const AllocationCallbacks> allocator
-                                                VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#    ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::VideoSessionKHR, Dispatch>>::type
-      createVideoSessionKHRUnique( const VideoSessionCreateInfoKHR & createInfo,
-                                   Optional<const AllocationCallbacks> allocator
-                                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif     /*VK_ENABLE_BETA_EXTENSIONS*/
-
-#if defined( VK_ENABLE_BETA_EXTENSIONS )
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result createVideoSessionParametersKHR(
-      const VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR * pCreateInfo,
-      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                 pAllocator,
-      VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR *                 pVideoSessionParameters,
-      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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
-      typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR>::type
-      createVideoSessionParametersKHR( const VideoSessionParametersCreateInfoKHR & createInfo,
-                                       Optional<const AllocationCallbacks> allocator
-                                                          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#    ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR, Dispatch>>::type
-      createVideoSessionParametersKHRUnique( const VideoSessionParametersCreateInfoKHR & createInfo,
-                                             Optional<const AllocationCallbacks> allocator
-                                                                VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif     /*VK_ENABLE_BETA_EXTENSIONS*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result debugMarkerSetObjectNameEXT(
-      const VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT * pNameInfo,
-      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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
-      debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT & nameInfo,
-                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result debugMarkerSetObjectTagEXT(
-      const VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT * pTagInfo,
-      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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
-      debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT & tagInfo,
-                                  Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      deferredOperationJoinKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
-                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#else
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      deferredOperationJoinKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
-                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void destroyAccelerationStructureKHR( 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 destroyAccelerationStructureKHR(
-      VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
-      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( 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::AccelerationStructureNV     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 destroyAccelerationStructureNV(
-      VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
-      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( VULKAN_HPP_NAMESPACE::AccelerationStructureNV     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::AccelerationStructureNV 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,
-                        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 destroyBuffer( VULKAN_HPP_NAMESPACE::Buffer buffer           VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
-                        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( VULKAN_HPP_NAMESPACE::Buffer                      buffer,
-                  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::Buffer                  buffer,
-                  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 destroyBufferView( VULKAN_HPP_NAMESPACE::BufferView                  bufferView,
-                            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
-      destroyBufferView( VULKAN_HPP_NAMESPACE::BufferView bufferView   VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
-                         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( VULKAN_HPP_NAMESPACE::BufferView                  bufferView,
-                  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::BufferView              bufferView,
-                  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 destroyCommandPool( VULKAN_HPP_NAMESPACE::CommandPool                 commandPool,
-                             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
-      destroyCommandPool( VULKAN_HPP_NAMESPACE::CommandPool commandPool VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
-                          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( VULKAN_HPP_NAMESPACE::CommandPool                 commandPool,
-                  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::CommandPool             commandPool,
-                  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 destroyCuFunctionNVX( VULKAN_HPP_NAMESPACE::CuFunctionNVX               function,
-                               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 destroyCuFunctionNVX( VULKAN_HPP_NAMESPACE::CuFunctionNVX function,
-                               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( VULKAN_HPP_NAMESPACE::CuFunctionNVX               function,
-                  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::CuFunctionNVX           function,
-                  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 destroyCuModuleNVX( VULKAN_HPP_NAMESPACE::CuModuleNVX                 module,
-                             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
-      destroyCuModuleNVX( VULKAN_HPP_NAMESPACE::CuModuleNVX             module,
-                          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( VULKAN_HPP_NAMESPACE::CuModuleNVX                 module,
-                  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::CuModuleNVX             module,
-                  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 destroyDeferredOperationKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR        operation,
-                                      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 destroyDeferredOperationKHR(
-      VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
-      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( VULKAN_HPP_NAMESPACE::DeferredOperationKHR        operation,
-                  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::DeferredOperationKHR    operation,
-                  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 destroyDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool              descriptorPool,
-                                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 destroyDescriptorPool(
-      VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
-      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( VULKAN_HPP_NAMESPACE::DescriptorPool              descriptorPool,
-                  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::DescriptorPool          descriptorPool,
-                  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 destroyDescriptorSetLayout( VULKAN_HPP_NAMESPACE::DescriptorSetLayout         descriptorSetLayout,
-                                     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 destroyDescriptorSetLayout(
-      VULKAN_HPP_NAMESPACE::DescriptorSetLayout descriptorSetLayout VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
-      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( VULKAN_HPP_NAMESPACE::DescriptorSetLayout         descriptorSetLayout,
-                  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::DescriptorSetLayout     descriptorSetLayout,
-                  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 destroyDescriptorUpdateTemplate( 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 destroyDescriptorUpdateTemplate(
-      VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
-      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( 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,
-                                             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 destroyDescriptorUpdateTemplateKHR(
-      VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
-      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;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void destroy( 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 destroyEvent( VULKAN_HPP_NAMESPACE::Event                       event,
-                       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 destroyEvent( VULKAN_HPP_NAMESPACE::Event event             VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
-                       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( VULKAN_HPP_NAMESPACE::Event                       event,
-                  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::Event                   event,
-                  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 destroyFence( VULKAN_HPP_NAMESPACE::Fence                       fence,
-                       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 destroyFence( VULKAN_HPP_NAMESPACE::Fence fence             VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
-                       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( VULKAN_HPP_NAMESPACE::Fence                       fence,
-                  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::Fence                   fence,
-                  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 destroyFramebuffer( VULKAN_HPP_NAMESPACE::Framebuffer                 framebuffer,
-                             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
-      destroyFramebuffer( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
-                          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( VULKAN_HPP_NAMESPACE::Framebuffer                 framebuffer,
-                  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::Framebuffer             framebuffer,
-                  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 destroyImage( VULKAN_HPP_NAMESPACE::Image                       image,
-                       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 destroyImage( VULKAN_HPP_NAMESPACE::Image image             VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
-                       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( VULKAN_HPP_NAMESPACE::Image                       image,
-                  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::Image                   image,
-                  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 destroyImageView( VULKAN_HPP_NAMESPACE::ImageView                   imageView,
-                           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 destroyImageView( VULKAN_HPP_NAMESPACE::ImageView imageView     VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
-                           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( VULKAN_HPP_NAMESPACE::ImageView                   imageView,
-                  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::ImageView               imageView,
-                  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 destroyIndirectCommandsLayoutNV( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV    indirectCommandsLayout,
-                                          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 destroyIndirectCommandsLayoutNV(
-      VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
-      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( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV    indirectCommandsLayout,
-                  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::IndirectCommandsLayoutNV indirectCommandsLayout,
-                  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 destroyPipeline( VULKAN_HPP_NAMESPACE::Pipeline                    pipeline,
-                          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 destroyPipeline( VULKAN_HPP_NAMESPACE::Pipeline pipeline       VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
-                          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( VULKAN_HPP_NAMESPACE::Pipeline                    pipeline,
-                  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::Pipeline                pipeline,
-                  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 destroyPipelineCache( VULKAN_HPP_NAMESPACE::PipelineCache               pipelineCache,
-                               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 destroyPipelineCache( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
-                               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( VULKAN_HPP_NAMESPACE::PipelineCache               pipelineCache,
-                  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::PipelineCache           pipelineCache,
-                  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 destroyPipelineLayout( VULKAN_HPP_NAMESPACE::PipelineLayout              pipelineLayout,
-                                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 destroyPipelineLayout(
-      VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
-      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( VULKAN_HPP_NAMESPACE::PipelineLayout              pipelineLayout,
-                  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::PipelineLayout          pipelineLayout,
-                  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 destroyPrivateDataSlotEXT( VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT          privateDataSlot,
-                                    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 destroyPrivateDataSlotEXT(
-      VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
-      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( VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT          privateDataSlot,
-                  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::PrivateDataSlotEXT      privateDataSlot,
-                  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 destroyQueryPool( VULKAN_HPP_NAMESPACE::QueryPool                   queryPool,
-                           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 destroyQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool     VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
-                           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( VULKAN_HPP_NAMESPACE::QueryPool                   queryPool,
-                  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::QueryPool               queryPool,
-                  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 destroyRenderPass( VULKAN_HPP_NAMESPACE::RenderPass                  renderPass,
-                            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
-      destroyRenderPass( VULKAN_HPP_NAMESPACE::RenderPass renderPass   VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
-                         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( VULKAN_HPP_NAMESPACE::RenderPass                  renderPass,
-                  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::RenderPass              renderPass,
-                  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 destroySampler( VULKAN_HPP_NAMESPACE::Sampler                     sampler,
-                         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 destroySampler( VULKAN_HPP_NAMESPACE::Sampler sampler         VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
-                         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( VULKAN_HPP_NAMESPACE::Sampler                     sampler,
-                  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::Sampler                 sampler,
-                  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 destroySamplerYcbcrConversion( 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 destroySamplerYcbcrConversion(
-      VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
-      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( 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,
-                                           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 destroySamplerYcbcrConversionKHR(
-      VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
-      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,
-                           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 destroySemaphore( VULKAN_HPP_NAMESPACE::Semaphore semaphore     VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
-                           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( VULKAN_HPP_NAMESPACE::Semaphore                   semaphore,
-                  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::Semaphore               semaphore,
-                  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 destroyShaderModule( VULKAN_HPP_NAMESPACE::ShaderModule                shaderModule,
-                              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
-      destroyShaderModule( VULKAN_HPP_NAMESPACE::ShaderModule shaderModule VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
-                           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( VULKAN_HPP_NAMESPACE::ShaderModule                shaderModule,
-                  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::ShaderModule            shaderModule,
-                  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 destroySwapchainKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR                swapchain,
-                              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
-      destroySwapchainKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain  VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
-                           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( VULKAN_HPP_NAMESPACE::SwapchainKHR                swapchain,
-                  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::SwapchainKHR            swapchain,
-                  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 destroyValidationCacheEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT          validationCache,
-                                    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 destroyValidationCacheEXT(
-      VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
-      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( VULKAN_HPP_NAMESPACE::ValidationCacheEXT          validationCache,
-                  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::ValidationCacheEXT      validationCache,
-                  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*/
-
-#if defined( VK_ENABLE_BETA_EXTENSIONS )
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void
-      destroyVideoSessionKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR             videoSession,
-                              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 destroyVideoSessionKHR(
-      VULKAN_HPP_NAMESPACE::VideoSessionKHR         videoSession,
-      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*/
-
-#if defined( VK_ENABLE_BETA_EXTENSIONS )
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void destroy( VULKAN_HPP_NAMESPACE::VideoSessionKHR             videoSession,
-                  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::VideoSessionKHR         videoSession,
-                  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*/
-
-#if defined( VK_ENABLE_BETA_EXTENSIONS )
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void destroyVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR   videoSessionParameters,
-                                           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 destroyVideoSessionParametersKHR(
-      VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters,
-      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*/
-
-#if defined( VK_ENABLE_BETA_EXTENSIONS )
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void destroy( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR   videoSessionParameters,
-                  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::VideoSessionParametersKHR videoSessionParameters,
-                  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 VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#else
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
-      waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      displayPowerControlEXT( VULKAN_HPP_NAMESPACE::DisplayKHR                  display,
-                              const VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT * pDisplayPowerInfo,
-                              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>
-    typename ResultValueType<void>::type
-      displayPowerControlEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display,
-                              const DisplayPowerInfoEXT &      displayPowerInfo,
-                              Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      flushMappedMemoryRanges( uint32_t                                        memoryRangeCount,
-                               const VULKAN_HPP_NAMESPACE::MappedMemoryRange * pMemoryRanges,
-                               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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
-      flushMappedMemoryRanges( ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges,
-                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void freeCommandBuffers( VULKAN_HPP_NAMESPACE::CommandPool           commandPool,
-                             uint32_t                                    commandBufferCount,
-                             const VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers,
-                             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 freeCommandBuffers( VULKAN_HPP_NAMESPACE::CommandPool                             commandPool,
-                             ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers,
-                             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 free( VULKAN_HPP_NAMESPACE::CommandPool           commandPool,
-               uint32_t                                    commandBufferCount,
-               const VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers,
-               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 free( VULKAN_HPP_NAMESPACE::CommandPool                             commandPool,
-               ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers,
-               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>
-    Result freeDescriptorSets( VULKAN_HPP_NAMESPACE::DescriptorPool        descriptorPool,
-                               uint32_t                                    descriptorSetCount,
-                               const VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets,
-                               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>
-    typename ResultValueType<void>::type
-      freeDescriptorSets( VULKAN_HPP_NAMESPACE::DescriptorPool                          descriptorPool,
-                          ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets,
-                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    Result free( VULKAN_HPP_NAMESPACE::DescriptorPool        descriptorPool,
-                 uint32_t                                    descriptorSetCount,
-                 const VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets,
-                 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>
-    typename ResultValueType<void>::type
-      free( VULKAN_HPP_NAMESPACE::DescriptorPool                          descriptorPool,
-            ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets,
-            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void freeMemory( VULKAN_HPP_NAMESPACE::DeviceMemory                memory,
-                     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 freeMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory     VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
-                     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 free( VULKAN_HPP_NAMESPACE::DeviceMemory                memory,
-               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 free( VULKAN_HPP_NAMESPACE::DeviceMemory            memory,
-               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 getAccelerationStructureBuildSizesKHR(
-      VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR                 buildType,
-      const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR * pBuildInfo,
-      const uint32_t *                                                        pMaxPrimitiveCounts,
-      VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR *          pSizeInfo,
-      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>
-    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR
-                         getAccelerationStructureBuildSizesKHR(
-                           VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType,
-                           const AccelerationStructureBuildGeometryInfoKHR &       buildInfo,
-                           ArrayProxy<const uint32_t> const & maxPrimitiveCounts   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    DeviceAddress getAccelerationStructureAddressKHR(
-      const VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR * pInfo,
-      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>
-    DeviceAddress getAccelerationStructureAddressKHR(
-      const AccelerationStructureDeviceAddressInfoKHR & info,
-      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result getAccelerationStructureHandleNV(
-      VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
-      size_t                                        dataSize,
-      void *                                        pData,
-      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+    VULKAN_HPP_NODISCARD Result getRayTracingShaderGroupHandlesKHR(
+      VULKAN_HPP_NAMESPACE::Pipeline pipeline,
+      uint32_t                       firstGroup,
+      uint32_t                       groupCount,
+      size_t                         dataSize,
+      void *                         pData,
+      Dispatch const & d             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
-      getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
-                                        ArrayProxy<T> const &                         data,
-                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+      getRayTracingShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
+                                          uint32_t                       firstGroup,
+                                          uint32_t                       groupCount,
+                                          ArrayProxy<T> const &          data,
+                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename T,
               typename Allocator = std::allocator<T>,
               typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<std::vector<T, Allocator>>::type
-      getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
-                                        size_t                                        dataSize,
-                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+      getRayTracingShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
+                                          uint32_t                       firstGroup,
+                                          uint32_t                       groupCount,
+                                          size_t                         dataSize,
+                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<T>::type
-      getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
-                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void getAccelerationStructureMemoryRequirementsNV(
-      const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV * pInfo,
-      VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR *                              pMemoryRequirements,
-      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>
-    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR getAccelerationStructureMemoryRequirementsNV(
-      const AccelerationStructureMemoryRequirementsInfoNV & info,
-      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getAccelerationStructureMemoryRequirementsNV(
-      const AccelerationStructureMemoryRequirementsInfoNV & info,
-      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#if defined( VK_USE_PLATFORM_ANDROID_KHR )
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result getAndroidHardwareBufferPropertiesANDROID(
-      const struct AHardwareBuffer *                                 buffer,
-      VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID * pProperties,
-      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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
-      typename ResultValueType<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID>::type
-      getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer,
-                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<StructureChain<X, Y, Z...>>::type
-      getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer,
-                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_USE_PLATFORM_ANDROID_KHR*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    DeviceAddress
-      getBufferAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,
-                        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>
-    DeviceAddress
-      getBufferAddress( const BufferDeviceAddressInfo & info,
-                        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>
-    DeviceAddress
-      getBufferAddressEXT( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,
-                           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>
-    DeviceAddress
-      getBufferAddressEXT( const BufferDeviceAddressInfo & info,
-                           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>
-    DeviceAddress
-      getBufferAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,
-                           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>
-    DeviceAddress
-      getBufferAddressKHR( const BufferDeviceAddressInfo & info,
-                           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 getBufferMemoryRequirements( VULKAN_HPP_NAMESPACE::Buffer               buffer,
-                                      VULKAN_HPP_NAMESPACE::MemoryRequirements * pMemoryRequirements,
-                                      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>
-    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements getBufferMemoryRequirements(
-      VULKAN_HPP_NAMESPACE::Buffer buffer,
-      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 getBufferMemoryRequirements2( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 * pInfo,
-                                       VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                 pMemoryRequirements,
-                                       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>
-    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getBufferMemoryRequirements2(
-      const BufferMemoryRequirementsInfo2 & info,
-      Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getBufferMemoryRequirements2(
-      const BufferMemoryRequirementsInfo2 & info,
-      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 getBufferMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 * pInfo,
-                                          VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements,
-                                          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>
-    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getBufferMemoryRequirements2KHR(
-      const BufferMemoryRequirementsInfo2 & info,
-      Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getBufferMemoryRequirements2KHR(
-      const BufferMemoryRequirementsInfo2 & info,
-      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>
-    uint64_t getBufferOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,
-                                            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>
-    uint64_t getBufferOpaqueCaptureAddress( const BufferDeviceAddressInfo & info,
-                                            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>
-    uint64_t getBufferOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,
-                                               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>
-    uint64_t getBufferOpaqueCaptureAddressKHR( const BufferDeviceAddressInfo & info,
-                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
-      VULKAN_HPP_NOEXCEPT;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result getCalibratedTimestampsEXT(
-      uint32_t                                                 timestampCount,
-      const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT * pTimestampInfos,
-      uint64_t *                                               pTimestamps,
-      uint64_t *                                               pMaxDeviation,
-      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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<uint64_t>::type getCalibratedTimestampsEXT(
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT> const & timestampInfos,
-      ArrayProxy<uint64_t> const &                                               timestamps,
-      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename Uint64_tAllocator = std::allocator<uint64_t>,
-              typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
-      typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type
-      getCalibratedTimestampsEXT(
-        ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT> const & timestampInfos,
-        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename Uint64_tAllocator = std::allocator<uint64_t>,
-              typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B                 = Uint64_tAllocator,
-              typename std::enable_if<std::is_same<typename B::value_type, uint64_t>::value, int>::type = 0>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
-      typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type
-      getCalibratedTimestampsEXT(
-        ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT> const & timestampInfos,
-        Uint64_tAllocator &                                                        uint64_tAllocator,
-        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    uint32_t getDeferredOperationMaxConcurrencyKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
-                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
-      VULKAN_HPP_NOEXCEPT;
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result getDeferredOperationResultKHR(
-      VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
-      Dispatch const & d                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#else
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      getDeferredOperationResultKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
-                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void getDescriptorSetLayoutSupport( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo * pCreateInfo,
-                                        VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport *          pSupport,
-                                        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>
-    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport getDescriptorSetLayoutSupport(
-      const DescriptorSetLayoutCreateInfo & createInfo,
-      Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getDescriptorSetLayoutSupport(
-      const DescriptorSetLayoutCreateInfo & createInfo,
-      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 getDescriptorSetLayoutSupportKHR( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo * pCreateInfo,
-                                           VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport *          pSupport,
-                                           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>
-    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport getDescriptorSetLayoutSupportKHR(
-      const DescriptorSetLayoutCreateInfo & createInfo,
-      Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getDescriptorSetLayoutSupportKHR(
-      const DescriptorSetLayoutCreateInfo & createInfo,
-      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 getAccelerationStructureCompatibilityKHR(
-      const VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR * pVersionInfo,
-      VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR *     pCompatibility,
-      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>
-    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR
-      getAccelerationStructureCompatibilityKHR( const AccelerationStructureVersionInfoKHR & versionInfo,
-                                                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 getGroupPeerMemoryFeatures( uint32_t                                       heapIndex,
-                                     uint32_t                                       localDeviceIndex,
-                                     uint32_t                                       remoteDeviceIndex,
-                                     VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags * pPeerMemoryFeatures,
-                                     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>
-    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags getGroupPeerMemoryFeatures(
-      uint32_t           heapIndex,
-      uint32_t           localDeviceIndex,
-      uint32_t           remoteDeviceIndex,
-      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 getGroupPeerMemoryFeaturesKHR( uint32_t                                       heapIndex,
-                                        uint32_t                                       localDeviceIndex,
-                                        uint32_t                                       remoteDeviceIndex,
-                                        VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags * pPeerMemoryFeatures,
-                                        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>
-    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags getGroupPeerMemoryFeaturesKHR(
-      uint32_t           heapIndex,
-      uint32_t           localDeviceIndex,
-      uint32_t           remoteDeviceIndex,
-      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result getGroupPresentCapabilitiesKHR(
-      VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR * pDeviceGroupPresentCapabilities,
-      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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
-      typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR>::type
-      getGroupPresentCapabilitiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#if defined( VK_USE_PLATFORM_WIN32_KHR )
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result getGroupSurfacePresentModes2EXT(
-      const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
-      VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR *      pModes,
-      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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
-      typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR>::type
-      getGroupSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
-                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_USE_PLATFORM_WIN32_KHR*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result getGroupSurfacePresentModesKHR(
-      VULKAN_HPP_NAMESPACE::SurfaceKHR                       surface,
-      VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR * pModes,
-      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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
-      typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR>::type
-      getGroupSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
-                                      Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void getMemoryCommitment( VULKAN_HPP_NAMESPACE::DeviceMemory memory,
-                              VULKAN_HPP_NAMESPACE::DeviceSize * pCommittedMemoryInBytes,
-                              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>
-    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceSize
-                         getMemoryCommitment( VULKAN_HPP_NAMESPACE::DeviceMemory memory,
-                                              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>
-    uint64_t getMemoryOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo * pInfo,
-                                            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>
-    uint64_t getMemoryOpaqueCaptureAddress( const DeviceMemoryOpaqueCaptureAddressInfo & info,
-                                            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>
-    uint64_t getMemoryOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo * pInfo,
-                                               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>
-    uint64_t getMemoryOpaqueCaptureAddressKHR( const DeviceMemoryOpaqueCaptureAddressInfo & info,
-                                               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>
-    PFN_vkVoidFunction
-      getProcAddr( const char *       pName,
-                   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>
-    PFN_vkVoidFunction
-      getProcAddr( const std::string & name,
-                   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 getQueue( uint32_t                      queueFamilyIndex,
-                   uint32_t                      queueIndex,
-                   VULKAN_HPP_NAMESPACE::Queue * pQueue,
-                   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>
-    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Queue
-                         getQueue( uint32_t           queueFamilyIndex,
-                                   uint32_t           queueIndex,
-                                   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 getQueue2( const VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 * pQueueInfo,
-                    VULKAN_HPP_NAMESPACE::Queue *                  pQueue,
-                    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>
-    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Queue
-                         getQueue2( const DeviceQueueInfo2 & queueInfo,
-                                    Dispatch const & d       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      getEventStatus( VULKAN_HPP_NAMESPACE::Event event,
-                      Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#else
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result getEventStatus( VULKAN_HPP_NAMESPACE::Event event,
-                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      getFenceFdKHR( const VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR * pGetFdInfo,
-                     int *                                           pFd,
-                     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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<int>::type
-      getFenceFdKHR( const FenceGetFdInfoKHR & getFdInfo,
-                     Dispatch const & d        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      getFenceStatus( VULKAN_HPP_NAMESPACE::Fence fence,
-                      Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#else
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result getFenceStatus( VULKAN_HPP_NAMESPACE::Fence fence,
-                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#if defined( VK_USE_PLATFORM_WIN32_KHR )
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      getFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR * pGetWin32HandleInfo,
-                              HANDLE *                                                 pHandle,
-                              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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<HANDLE>::type
-      getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR & getWin32HandleInfo,
-                              Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_USE_PLATFORM_WIN32_KHR*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void getGeneratedCommandsMemoryRequirementsNV(
-      const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV * pInfo,
-      VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                             pMemoryRequirements,
-      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>
-    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getGeneratedCommandsMemoryRequirementsNV(
-      const GeneratedCommandsMemoryRequirementsInfoNV & info,
-      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getGeneratedCommandsMemoryRequirementsNV(
-      const GeneratedCommandsMemoryRequirementsInfoNV & info,
-      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result getImageDrmFormatModifierPropertiesEXT(
-      VULKAN_HPP_NAMESPACE::Image                                 image,
-      VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT * pProperties,
-      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>
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT>::type
-      getImageDrmFormatModifierPropertiesEXT( VULKAN_HPP_NAMESPACE::Image image,
-                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void getImageMemoryRequirements( VULKAN_HPP_NAMESPACE::Image                image,
-                                     VULKAN_HPP_NAMESPACE::MemoryRequirements * pMemoryRequirements,
-                                     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>
-    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements getImageMemoryRequirements(
-      VULKAN_HPP_NAMESPACE::Image image,
-      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 getImageMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 * pInfo,
-                                      VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                pMemoryRequirements,
-                                      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>
-    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getImageMemoryRequirements2(
-      const ImageMemoryRequirementsInfo2 & info,
-      Dispatch const & d                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getImageMemoryRequirements2(
-      const ImageMemoryRequirementsInfo2 & info,
-      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 getImageMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 * pInfo,
-                                         VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                pMemoryRequirements,
-                                         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>
-    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getImageMemoryRequirements2KHR(
-      const ImageMemoryRequirementsInfo2 & info,
-      Dispatch const & d                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getImageMemoryRequirements2KHR(
-      const ImageMemoryRequirementsInfo2 & info,
-      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 getImageSparseMemoryRequirements(
-      VULKAN_HPP_NAMESPACE::Image                           image,
-      uint32_t *                                            pSparseMemoryRequirementCount,
-      VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements * pSparseMemoryRequirements,
-      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename SparseImageMemoryRequirementsAllocator = std::allocator<SparseImageMemoryRequirements>,
-              typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator>
-                         getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image,
-                                                           Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename SparseImageMemoryRequirementsAllocator = std::allocator<SparseImageMemoryRequirements>,
-              typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B                                      = SparseImageMemoryRequirementsAllocator,
-              typename std::enable_if<std::is_same<typename B::value_type, SparseImageMemoryRequirements>::value,
-                                      int>::type              = 0>
-    VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator>
-                         getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image              image,
-                                                           SparseImageMemoryRequirementsAllocator & sparseImageMemoryRequirementsAllocator,
-                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void getImageSparseMemoryRequirements2(
-      const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 * pInfo,
-      uint32_t *                                                       pSparseMemoryRequirementCount,
-      VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 *           pSparseMemoryRequirements,
-      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename SparseImageMemoryRequirements2Allocator = std::allocator<SparseImageMemoryRequirements2>,
-              typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
-                         getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info,
-                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename SparseImageMemoryRequirements2Allocator = std::allocator<SparseImageMemoryRequirements2>,
-              typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B                                       = SparseImageMemoryRequirements2Allocator,
-              typename std::enable_if<std::is_same<typename B::value_type, SparseImageMemoryRequirements2>::value,
-                                      int>::type               = 0>
-    VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
-                         getImageSparseMemoryRequirements2(
-                           const ImageSparseMemoryRequirementsInfo2 & info,
-                           SparseImageMemoryRequirements2Allocator &  sparseImageMemoryRequirements2Allocator,
-                           Dispatch const & d                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void getImageSparseMemoryRequirements2KHR(
-      const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 * pInfo,
-      uint32_t *                                                       pSparseMemoryRequirementCount,
-      VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 *           pSparseMemoryRequirements,
-      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename SparseImageMemoryRequirements2Allocator = std::allocator<SparseImageMemoryRequirements2>,
-              typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
-                         getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info,
-                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename SparseImageMemoryRequirements2Allocator = std::allocator<SparseImageMemoryRequirements2>,
-              typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B                                       = SparseImageMemoryRequirements2Allocator,
-              typename std::enable_if<std::is_same<typename B::value_type, SparseImageMemoryRequirements2>::value,
-                                      int>::type               = 0>
-    VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
-                         getImageSparseMemoryRequirements2KHR(
-                           const ImageSparseMemoryRequirementsInfo2 & info,
-                           SparseImageMemoryRequirements2Allocator &  sparseImageMemoryRequirements2Allocator,
-                           Dispatch const & d                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void getImageSubresourceLayout( VULKAN_HPP_NAMESPACE::Image                    image,
-                                    const VULKAN_HPP_NAMESPACE::ImageSubresource * pSubresource,
-                                    VULKAN_HPP_NAMESPACE::SubresourceLayout *      pLayout,
-                                    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>
-    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SubresourceLayout getImageSubresourceLayout(
-      VULKAN_HPP_NAMESPACE::Image image,
-      const ImageSubresource &    subresource,
-      Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      getImageViewAddressNVX( VULKAN_HPP_NAMESPACE::ImageView                       imageView,
-                              VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX * pProperties,
-                              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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
-      typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX>::type
-      getImageViewAddressNVX( VULKAN_HPP_NAMESPACE::ImageView imageView,
-                              Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    uint32_t
-      getImageViewHandleNVX( const VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX * pInfo,
-                             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>
-    uint32_t
-      getImageViewHandleNVX( const ImageViewHandleInfoNVX & info,
-                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#if defined( VK_USE_PLATFORM_ANDROID_KHR )
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result getMemoryAndroidHardwareBufferANDROID(
-      const VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID * pInfo,
-      struct AHardwareBuffer **                                               pBuffer,
-      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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<struct AHardwareBuffer *>::type
-      getMemoryAndroidHardwareBufferANDROID( const MemoryGetAndroidHardwareBufferInfoANDROID & info,
-                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_USE_PLATFORM_ANDROID_KHR*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      getMemoryFdKHR( const VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR * pGetFdInfo,
-                      int *                                            pFd,
-                      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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<int>::type
-      getMemoryFdKHR( const MemoryGetFdInfoKHR & getFdInfo,
-                      Dispatch const & d         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      getMemoryFdPropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
-                                int                                                    fd,
-                                VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR *          pMemoryFdProperties,
-                                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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR>::type
-      getMemoryFdPropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
-                                int                                                    fd,
-                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result getMemoryHostPointerPropertiesEXT(
-      VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
-      const void *                                           pHostPointer,
-      VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT * pMemoryHostPointerProperties,
-      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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
-      typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT>::type
-      getMemoryHostPointerPropertiesEXT( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
-                                         const void *                                           pHostPointer,
+      getRayTracingShaderGroupHandleKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
+                                         uint32_t                       firstGroup,
+                                         uint32_t                       groupCount,
                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
-#if defined( VK_USE_PLATFORM_WIN32_KHR )
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      getMemoryWin32HandleKHR( const VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR * pGetWin32HandleInfo,
-                               HANDLE *                                                  pHandle,
-                               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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<HANDLE>::type
-      getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR & getWin32HandleInfo,
-                               Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#if defined( VK_USE_PLATFORM_WIN32_KHR )
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      getMemoryWin32HandleNV( VULKAN_HPP_NAMESPACE::DeviceMemory                    memory,
-                              VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleType,
-                              HANDLE *                                              pHandle,
-                              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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<HANDLE>::type
-      getMemoryWin32HandleNV( VULKAN_HPP_NAMESPACE::DeviceMemory                    memory,
-                              VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleType,
-                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#if defined( VK_USE_PLATFORM_WIN32_KHR )
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result getMemoryWin32HandlePropertiesKHR(
-      VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
-      HANDLE                                                 handle,
-      VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR * pMemoryWin32HandleProperties,
-      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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
-      typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR>::type
-      getMemoryWin32HandlePropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
-                                         HANDLE                                                 handle,
-                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#if defined( VK_USE_PLATFORM_FUCHSIA )
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result getMemoryZirconHandleFUCHSIA(
-      const VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo,
-      zx_handle_t *                                                  pZirconHandle,
-      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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<zx_handle_t>::type
-      getMemoryZirconHandleFUCHSIA( const MemoryGetZirconHandleInfoFUCHSIA & getZirconHandleInfo,
-                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_USE_PLATFORM_FUCHSIA*/
-
-#if defined( VK_USE_PLATFORM_FUCHSIA )
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result getMemoryZirconHandlePropertiesFUCHSIA(
-      VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits      handleType,
-      zx_handle_t                                                 zirconHandle,
-      VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA * pMemoryZirconHandleProperties,
-      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>
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA>::type
-      getMemoryZirconHandlePropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
-                                              zx_handle_t                                            zirconHandle,
-                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_USE_PLATFORM_FUCHSIA*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result getPastPresentationTimingGOOGLE(
-      VULKAN_HPP_NAMESPACE::SwapchainKHR                   swapchain,
-      uint32_t *                                           pPresentationTimingCount,
-      VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE * pPresentationTimings,
-      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename PastPresentationTimingGOOGLEAllocator = std::allocator<PastPresentationTimingGOOGLE>,
-              typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD
-      typename ResultValueType<std::vector<PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator>>::type
-      getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
-                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <
-      typename PastPresentationTimingGOOGLEAllocator = std::allocator<PastPresentationTimingGOOGLE>,
-      typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-      typename B                                     = PastPresentationTimingGOOGLEAllocator,
-      typename std::enable_if<std::is_same<typename B::value_type, PastPresentationTimingGOOGLE>::value, int>::type = 0>
-    VULKAN_HPP_NODISCARD
-      typename ResultValueType<std::vector<PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator>>::type
-      getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR      swapchain,
-                                       PastPresentationTimingGOOGLEAllocator & pastPresentationTimingGOOGLEAllocator,
-                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result getPerformanceParameterINTEL(
-      VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL parameter,
-      VULKAN_HPP_NAMESPACE::PerformanceValueINTEL *       pValue,
-      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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::PerformanceValueINTEL>::type
-      getPerformanceParameterINTEL( VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL parameter,
-                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
-                            size_t *                            pDataSize,
-                            void *                              pData,
-                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Uint8_tAllocator = std::allocator<uint8_t>,
-              typename Dispatch         = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
-      getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
-                            Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename Uint8_tAllocator = std::allocator<uint8_t>,
-              typename Dispatch         = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B                = Uint8_tAllocator,
-              typename std::enable_if<std::is_same<typename B::value_type, uint8_t>::value, int>::type = 0>
-    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
-      getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
-                            Uint8_tAllocator &                  uint8_tAllocator,
-                            Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result getPipelineExecutableInternalRepresentationsKHR(
-      const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR *             pExecutableInfo,
-      uint32_t *                                                          pInternalRepresentationCount,
-      VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR * pInternalRepresentations,
-      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename PipelineExecutableInternalRepresentationKHRAllocator =
-                std::allocator<PipelineExecutableInternalRepresentationKHR>,
-              typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD
-      typename ResultValueType<std::vector<PipelineExecutableInternalRepresentationKHR,
-                                           PipelineExecutableInternalRepresentationKHRAllocator>>::type
-      getPipelineExecutableInternalRepresentationsKHR( const PipelineExecutableInfoKHR & executableInfo,
-                                                       Dispatch const & d
-                                                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <
-      typename PipelineExecutableInternalRepresentationKHRAllocator =
-        std::allocator<PipelineExecutableInternalRepresentationKHR>,
-      typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-      typename B                         = PipelineExecutableInternalRepresentationKHRAllocator,
-      typename std::enable_if<std::is_same<typename B::value_type, PipelineExecutableInternalRepresentationKHR>::value,
-                              int>::type = 0>
-    VULKAN_HPP_NODISCARD
-      typename ResultValueType<std::vector<PipelineExecutableInternalRepresentationKHR,
-                                           PipelineExecutableInternalRepresentationKHRAllocator>>::type
-      getPipelineExecutableInternalRepresentationsKHR(
-        const PipelineExecutableInfoKHR &                      executableInfo,
-        PipelineExecutableInternalRepresentationKHRAllocator & pipelineExecutableInternalRepresentationKHRAllocator,
-        Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result getPipelineExecutablePropertiesKHR(
-      const VULKAN_HPP_NAMESPACE::PipelineInfoKHR *           pPipelineInfo,
-      uint32_t *                                              pExecutableCount,
-      VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR * pProperties,
-      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename PipelineExecutablePropertiesKHRAllocator = std::allocator<PipelineExecutablePropertiesKHR>,
-              typename Dispatch                                 = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD typename ResultValueType<
-      std::vector<PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator>>::type
-      getPipelineExecutablePropertiesKHR( const PipelineInfoKHR & pipelineInfo,
-                                          Dispatch const & d      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename PipelineExecutablePropertiesKHRAllocator = std::allocator<PipelineExecutablePropertiesKHR>,
-              typename Dispatch                                 = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B                                        = PipelineExecutablePropertiesKHRAllocator,
-              typename std::enable_if<std::is_same<typename B::value_type, PipelineExecutablePropertiesKHR>::value,
-                                      int>::type                = 0>
-    VULKAN_HPP_NODISCARD typename ResultValueType<
-      std::vector<PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator>>::type
-      getPipelineExecutablePropertiesKHR(
-        const PipelineInfoKHR &                    pipelineInfo,
-        PipelineExecutablePropertiesKHRAllocator & pipelineExecutablePropertiesKHRAllocator,
-        Dispatch const & d                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result getPipelineExecutableStatisticsKHR(
-      const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR * pExecutableInfo,
-      uint32_t *                                              pStatisticCount,
-      VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR *  pStatistics,
-      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename PipelineExecutableStatisticKHRAllocator = std::allocator<PipelineExecutableStatisticKHR>,
-              typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD typename ResultValueType<
-      std::vector<PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator>>::type
-      getPipelineExecutableStatisticsKHR( const PipelineExecutableInfoKHR & executableInfo,
-                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename PipelineExecutableStatisticKHRAllocator = std::allocator<PipelineExecutableStatisticKHR>,
-              typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B                                       = PipelineExecutableStatisticKHRAllocator,
-              typename std::enable_if<std::is_same<typename B::value_type, PipelineExecutableStatisticKHR>::value,
-                                      int>::type               = 0>
-    VULKAN_HPP_NODISCARD typename ResultValueType<
-      std::vector<PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator>>::type
-      getPipelineExecutableStatisticsKHR(
-        const PipelineExecutableInfoKHR &         executableInfo,
-        PipelineExecutableStatisticKHRAllocator & pipelineExecutableStatisticKHRAllocator,
-        Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void getPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType         objectType,
-                            uint64_t                                 objectHandle,
-                            VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot,
-                            uint64_t *                               pData,
-                            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>
-    VULKAN_HPP_NODISCARD uint64_t
-      getPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType         objectType,
-                         uint64_t                                 objectHandle,
-                         VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot,
-                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      getQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool        queryPool,
-                           uint32_t                               firstQuery,
-                           uint32_t                               queryCount,
-                           size_t                                 dataSize,
-                           void *                                 pData,
-                           VULKAN_HPP_NAMESPACE::DeviceSize       stride,
-                           VULKAN_HPP_NAMESPACE::QueryResultFlags flags,
-                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      getQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool        queryPool,
-                           uint32_t                               firstQuery,
-                           uint32_t                               queryCount,
-                           ArrayProxy<T> const &                  data,
-                           VULKAN_HPP_NAMESPACE::DeviceSize       stride,
-                           VULKAN_HPP_NAMESPACE::QueryResultFlags flags,
-                           Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename T,
-              typename Allocator = std::allocator<T>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD ResultValue<std::vector<T, Allocator>>
-                         getQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool              queryPool,
-                                              uint32_t                                     firstQuery,
-                                              uint32_t                                     queryCount,
-                                              size_t                                       dataSize,
-                                              VULKAN_HPP_NAMESPACE::DeviceSize             stride,
-                                              VULKAN_HPP_NAMESPACE::QueryResultFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
-                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD ResultValue<T>
-                         getQueryPoolResult( VULKAN_HPP_NAMESPACE::QueryPool              queryPool,
-                                             uint32_t                                     firstQuery,
-                                             uint32_t                                     queryCount,
-                                             VULKAN_HPP_NAMESPACE::DeviceSize             stride,
-                                             VULKAN_HPP_NAMESPACE::QueryResultFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
-                                             Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD Result getRayTracingCaptureReplayShaderGroupHandlesKHR(
       VULKAN_HPP_NAMESPACE::Pipeline pipeline,
@@ -62071,72 +62905,6 @@ namespace VULKAN_HPP_NAMESPACE
                                                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result getRayTracingShaderGroupHandlesKHR(
-      VULKAN_HPP_NAMESPACE::Pipeline pipeline,
-      uint32_t                       firstGroup,
-      uint32_t                       groupCount,
-      size_t                         dataSize,
-      void *                         pData,
-      Dispatch const & d             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
-      getRayTracingShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
-                                          uint32_t                       firstGroup,
-                                          uint32_t                       groupCount,
-                                          ArrayProxy<T> const &          data,
-                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename T,
-              typename Allocator = std::allocator<T>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<std::vector<T, Allocator>>::type
-      getRayTracingShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
-                                          uint32_t                       firstGroup,
-                                          uint32_t                       groupCount,
-                                          size_t                         dataSize,
-                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<T>::type
-      getRayTracingShaderGroupHandleKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
-                                         uint32_t                       firstGroup,
-                                         uint32_t                       groupCount,
-                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result getRayTracingShaderGroupHandlesNV(
-      VULKAN_HPP_NAMESPACE::Pipeline pipeline,
-      uint32_t                       firstGroup,
-      uint32_t                       groupCount,
-      size_t                         dataSize,
-      void *                         pData,
-      Dispatch const & d             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
-      getRayTracingShaderGroupHandlesNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
-                                         uint32_t                       firstGroup,
-                                         uint32_t                       groupCount,
-                                         ArrayProxy<T> const &          data,
-                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename T,
-              typename Allocator = std::allocator<T>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<std::vector<T, Allocator>>::type
-      getRayTracingShaderGroupHandlesNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
-                                         uint32_t                       firstGroup,
-                                         uint32_t                       groupCount,
-                                         size_t                         dataSize,
-                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<T>::type
-      getRayTracingShaderGroupHandleNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
-                                        uint32_t                       firstGroup,
-                                        uint32_t                       groupCount,
-                                        Dispatch const & d             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     DeviceSize getRayTracingShaderGroupStackSizeKHR( VULKAN_HPP_NAMESPACE::Pipeline             pipeline,
                                                      uint32_t                                   group,
@@ -62144,82 +62912,50 @@ namespace VULKAN_HPP_NAMESPACE
                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
       VULKAN_HPP_NOEXCEPT;
 
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result getRefreshCycleDurationGOOGLE(
-      VULKAN_HPP_NAMESPACE::SwapchainKHR                 swapchain,
-      VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE * pDisplayTimingProperties,
-      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
-      typename ResultValueType<VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE>::type
-      getRefreshCycleDurationGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
-                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#if defined( VK_USE_PLATFORM_FUCHSIA )
+    //=== VK_FUCHSIA_external_memory ===
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void
-      getRenderAreaGranularity( VULKAN_HPP_NAMESPACE::RenderPass renderPass,
-                                VULKAN_HPP_NAMESPACE::Extent2D * pGranularity,
-                                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>
-    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Extent2D
-                         getRenderAreaGranularity( VULKAN_HPP_NAMESPACE::RenderPass renderPass,
-                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      getSemaphoreCounterValue( VULKAN_HPP_NAMESPACE::Semaphore semaphore,
-                                uint64_t *                      pValue,
-                                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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<uint64_t>::type
-      getSemaphoreCounterValue( VULKAN_HPP_NAMESPACE::Semaphore semaphore,
-                                Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result getSemaphoreCounterValueKHR(
-      VULKAN_HPP_NAMESPACE::Semaphore semaphore,
-      uint64_t *                      pValue,
-      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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<uint64_t>::type
-      getSemaphoreCounterValueKHR( VULKAN_HPP_NAMESPACE::Semaphore semaphore,
-                                   Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      getSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR * pGetFdInfo,
-                         int *                                               pFd,
-                         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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<int>::type
-      getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR & getFdInfo,
-                         Dispatch const & d            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#if defined( VK_USE_PLATFORM_WIN32_KHR )
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result getSemaphoreWin32HandleKHR(
-      const VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR * pGetWin32HandleInfo,
-      HANDLE *                                                     pHandle,
+    VULKAN_HPP_NODISCARD Result getMemoryZirconHandleFUCHSIA(
+      const VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo,
+      zx_handle_t *                                                  pZirconHandle,
       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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<HANDLE>::type
-      getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo,
-                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<zx_handle_t>::type
+      getMemoryZirconHandleFUCHSIA( const MemoryGetZirconHandleInfoFUCHSIA & getZirconHandleInfo,
+                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_USE_PLATFORM_WIN32_KHR*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result getMemoryZirconHandlePropertiesFUCHSIA(
+      VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits      handleType,
+      zx_handle_t                                                 zirconHandle,
+      VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA * pMemoryZirconHandleProperties,
+      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>
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA>::type
+      getMemoryZirconHandlePropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
+                                              zx_handle_t                                            zirconHandle,
+                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VK_USE_PLATFORM_FUCHSIA*/
 
 #if defined( VK_USE_PLATFORM_FUCHSIA )
+    //=== VK_FUCHSIA_external_semaphore ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result importSemaphoreZirconHandleFUCHSIA(
+      const VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA * pImportSemaphoreZirconHandleInfo,
+      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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type importSemaphoreZirconHandleFUCHSIA(
+      const ImportSemaphoreZirconHandleInfoFUCHSIA & importSemaphoreZirconHandleInfo,
+      Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD Result getSemaphoreZirconHandleFUCHSIA(
       const VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo,
@@ -62233,637 +62969,6 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VK_USE_PLATFORM_FUCHSIA*/
 
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline            pipeline,
-                        VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage,
-                        VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD   infoType,
-                        size_t *                                  pInfoSize,
-                        void *                                    pInfo,
-                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Uint8_tAllocator = std::allocator<uint8_t>,
-              typename Dispatch         = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
-      getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline            pipeline,
-                        VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage,
-                        VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD   infoType,
-                        Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename Uint8_tAllocator = std::allocator<uint8_t>,
-              typename Dispatch         = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B                = Uint8_tAllocator,
-              typename std::enable_if<std::is_same<typename B::value_type, uint8_t>::value, int>::type = 0>
-    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
-      getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline            pipeline,
-                        VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage,
-                        VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD   infoType,
-                        Uint8_tAllocator &                        uint8_tAllocator,
-                        Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      getSwapchainCounterEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR              swapchain,
-                              VULKAN_HPP_NAMESPACE::SurfaceCounterFlagBitsEXT counter,
-                              uint64_t *                                      pCounterValue,
-                              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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<uint64_t>::type
-      getSwapchainCounterEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR              swapchain,
-                              VULKAN_HPP_NAMESPACE::SurfaceCounterFlagBitsEXT counter,
-                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      getSwapchainImagesKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
-                             uint32_t *                         pSwapchainImageCount,
-                             VULKAN_HPP_NAMESPACE::Image *      pSwapchainImages,
-                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename ImageAllocator = std::allocator<Image>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<Image, ImageAllocator>>::type
-      getSwapchainImagesKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
-                             Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename ImageAllocator = std::allocator<Image>,
-              typename Dispatch       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B              = ImageAllocator,
-              typename std::enable_if<std::is_same<typename B::value_type, Image>::value, int>::type = 0>
-    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<Image, ImageAllocator>>::type
-      getSwapchainImagesKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
-                             ImageAllocator &                   imageAllocator,
-                             Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      getSwapchainStatusKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
-                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#else
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result getSwapchainStatusKHR(
-      VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result getValidationCacheDataEXT(
-      VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache,
-      size_t *                                 pDataSize,
-      void *                                   pData,
-      Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Uint8_tAllocator = std::allocator<uint8_t>,
-              typename Dispatch         = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
-      getValidationCacheDataEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache,
-                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename Uint8_tAllocator = std::allocator<uint8_t>,
-              typename Dispatch         = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B                = Uint8_tAllocator,
-              typename std::enable_if<std::is_same<typename B::value_type, uint8_t>::value, int>::type = 0>
-    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
-      getValidationCacheDataEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache,
-                                 Uint8_tAllocator &                       uint8_tAllocator,
-                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#if defined( VK_ENABLE_BETA_EXTENSIONS )
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result getVideoSessionMemoryRequirementsKHR(
-      VULKAN_HPP_NAMESPACE::VideoSessionKHR               videoSession,
-      uint32_t *                                          pVideoSessionMemoryRequirementsCount,
-      VULKAN_HPP_NAMESPACE::VideoGetMemoryPropertiesKHR * pVideoSessionMemoryRequirements,
-      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename VideoGetMemoryPropertiesKHRAllocator = std::allocator<VideoGetMemoryPropertiesKHR>,
-              typename Dispatch                             = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD
-      typename ResultValueType<std::vector<VideoGetMemoryPropertiesKHR, VideoGetMemoryPropertiesKHRAllocator>>::type
-      getVideoSessionMemoryRequirementsKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession,
-                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <
-      typename VideoGetMemoryPropertiesKHRAllocator = std::allocator<VideoGetMemoryPropertiesKHR>,
-      typename Dispatch                             = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-      typename B                                    = VideoGetMemoryPropertiesKHRAllocator,
-      typename std::enable_if<std::is_same<typename B::value_type, VideoGetMemoryPropertiesKHR>::value, int>::type = 0>
-    VULKAN_HPP_NODISCARD
-      typename ResultValueType<std::vector<VideoGetMemoryPropertiesKHR, VideoGetMemoryPropertiesKHRAllocator>>::type
-      getVideoSessionMemoryRequirementsKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR  videoSession,
-                                            VideoGetMemoryPropertiesKHRAllocator & videoGetMemoryPropertiesKHRAllocator,
-                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_ENABLE_BETA_EXTENSIONS*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      importFenceFdKHR( const VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR * pImportFenceFdInfo,
-                        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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
-      importFenceFdKHR( const ImportFenceFdInfoKHR & importFenceFdInfo,
-                        Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#if defined( VK_USE_PLATFORM_WIN32_KHR )
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result importFenceWin32HandleKHR(
-      const VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR * pImportFenceWin32HandleInfo,
-      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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
-      importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo,
-                                 Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_USE_PLATFORM_WIN32_KHR*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      importSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR * pImportSemaphoreFdInfo,
-                            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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
-      importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo,
-                            Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#if defined( VK_USE_PLATFORM_WIN32_KHR )
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result importSemaphoreWin32HandleKHR(
-      const VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR * pImportSemaphoreWin32HandleInfo,
-      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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
-      importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo,
-                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#if defined( VK_USE_PLATFORM_FUCHSIA )
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result importSemaphoreZirconHandleFUCHSIA(
-      const VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA * pImportSemaphoreZirconHandleInfo,
-      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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type importSemaphoreZirconHandleFUCHSIA(
-      const ImportSemaphoreZirconHandleInfoFUCHSIA & importSemaphoreZirconHandleInfo,
-      Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_USE_PLATFORM_FUCHSIA*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result initializePerformanceApiINTEL(
-      const VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL * pInitializeInfo,
-      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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
-      initializePerformanceApiINTEL( const InitializePerformanceApiInfoINTEL & initializeInfo,
-                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result invalidateMappedMemoryRanges(
-      uint32_t                                        memoryRangeCount,
-      const VULKAN_HPP_NAMESPACE::MappedMemoryRange * pMemoryRanges,
-      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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
-      invalidateMappedMemoryRanges( ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges,
-                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      mapMemory( VULKAN_HPP_NAMESPACE::DeviceMemory   memory,
-                 VULKAN_HPP_NAMESPACE::DeviceSize     offset,
-                 VULKAN_HPP_NAMESPACE::DeviceSize     size,
-                 VULKAN_HPP_NAMESPACE::MemoryMapFlags flags,
-                 void **                              ppData,
-                 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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void *>::type
-      mapMemory( VULKAN_HPP_NAMESPACE::DeviceMemory         memory,
-                 VULKAN_HPP_NAMESPACE::DeviceSize           offset,
-                 VULKAN_HPP_NAMESPACE::DeviceSize           size,
-                 VULKAN_HPP_NAMESPACE::MemoryMapFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
-                 Dispatch const & d                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      mergePipelineCaches( VULKAN_HPP_NAMESPACE::PipelineCache         dstCache,
-                           uint32_t                                    srcCacheCount,
-                           const VULKAN_HPP_NAMESPACE::PipelineCache * pSrcCaches,
-                           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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
-      mergePipelineCaches( VULKAN_HPP_NAMESPACE::PipelineCache                           dstCache,
-                           ArrayProxy<const VULKAN_HPP_NAMESPACE::PipelineCache> const & srcCaches,
-                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      mergeValidationCachesEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT         dstCache,
-                                uint32_t                                         srcCacheCount,
-                                const VULKAN_HPP_NAMESPACE::ValidationCacheEXT * pSrcCaches,
-                                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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
-      mergeValidationCachesEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT                           dstCache,
-                                ArrayProxy<const VULKAN_HPP_NAMESPACE::ValidationCacheEXT> const & srcCaches,
-                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      registerEventEXT( const VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT *  pDeviceEventInfo,
-                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                        VULKAN_HPP_NAMESPACE::Fence *                     pFence,
-                        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>
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::Fence>::type
-      registerEventEXT( const DeviceEventInfoEXT &                    deviceEventInfo,
-                        Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                        Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>>::type
-      registerEventEXTUnique( const DeviceEventInfoEXT & deviceEventInfo,
-                              Optional<const AllocationCallbacks> allocator
-                                                 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      registerDisplayEventEXT( VULKAN_HPP_NAMESPACE::DisplayKHR                  display,
-                               const VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT * pDisplayEventInfo,
-                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                               VULKAN_HPP_NAMESPACE::Fence *                     pFence,
-                               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>
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::Fence>::type registerDisplayEventEXT(
-      VULKAN_HPP_NAMESPACE::DisplayKHR              display,
-      const DisplayEventInfoEXT &                   displayEventInfo,
-      Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-      Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>>::type
-      registerDisplayEventEXTUnique( VULKAN_HPP_NAMESPACE::DisplayKHR display,
-                                     const DisplayEventInfoEXT &      displayEventInfo,
-                                     Optional<const AllocationCallbacks> allocator
-                                                        VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#if defined( VK_USE_PLATFORM_WIN32_KHR )
-#  ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result releaseFullScreenExclusiveModeEXT(
-      VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
-      Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#  else
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
-         releaseFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
-                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result releasePerformanceConfigurationINTEL(
-      VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,
-      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#else
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type releasePerformanceConfigurationINTEL(
-      VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
-      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      release( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,
-               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#else
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
-      release( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,
-               Dispatch const & d                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void
-      releaseProfilingLockKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      resetCommandPool( VULKAN_HPP_NAMESPACE::CommandPool           commandPool,
-                        VULKAN_HPP_NAMESPACE::CommandPoolResetFlags flags,
-                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#else
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    typename ResultValueType<void>::type
-      resetCommandPool( VULKAN_HPP_NAMESPACE::CommandPool                 commandPool,
-                        VULKAN_HPP_NAMESPACE::CommandPoolResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
-                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    Result resetDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool           descriptorPool,
-                                VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags,
-                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#else
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    typename ResultValueType<void>::type
-      resetDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool                 descriptorPool,
-                           VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
-                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      resetEvent( VULKAN_HPP_NAMESPACE::Event event,
-                  Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#else
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    typename ResultValueType<void>::type
-      resetEvent( VULKAN_HPP_NAMESPACE::Event event,
-                  Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      resetFences( uint32_t                            fenceCount,
-                   const VULKAN_HPP_NAMESPACE::Fence * pFences,
-                   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>
-    typename ResultValueType<void>::type
-      resetFences( ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences,
-                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void resetQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
-                         uint32_t                        firstQuery,
-                         uint32_t                        queryCount,
-                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void resetQueryPoolEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
-                            uint32_t                        firstQuery,
-                            uint32_t                        queryCount,
-                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result setDebugUtilsObjectNameEXT(
-      const VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT * pNameInfo,
-      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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
-      setDebugUtilsObjectNameEXT( const DebugUtilsObjectNameInfoEXT & nameInfo,
-                                  Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result setDebugUtilsObjectTagEXT(
-      const VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT * pTagInfo,
-      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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
-      setDebugUtilsObjectTagEXT( const DebugUtilsObjectTagInfoEXT & tagInfo,
-                                 Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      setEvent( VULKAN_HPP_NAMESPACE::Event event,
-                Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#else
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
-      setEvent( VULKAN_HPP_NAMESPACE::Event event, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void setHdrMetadataEXT( uint32_t                                     swapchainCount,
-                            const VULKAN_HPP_NAMESPACE::SwapchainKHR *   pSwapchains,
-                            const VULKAN_HPP_NAMESPACE::HdrMetadataEXT * pMetadata,
-                            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 setHdrMetadataEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainKHR> const &   swapchains,
-                            ArrayProxy<const VULKAN_HPP_NAMESPACE::HdrMetadataEXT> const & metadata,
-                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
-      VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void setLocalDimmingAMD( VULKAN_HPP_NAMESPACE::SwapchainKHR swapChain,
-                             VULKAN_HPP_NAMESPACE::Bool32       localDimmingEnable,
-                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType         objectType,
-                         uint64_t                                 objectHandle,
-                         VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot,
-                         uint64_t                                 data,
-                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#else
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    typename ResultValueType<void>::type
-         setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType         objectType,
-                            uint64_t                                 objectHandle,
-                            VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot,
-                            uint64_t                                 data,
-                            Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      signalSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo * pSignalInfo,
-                       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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
-      signalSemaphore( const SemaphoreSignalInfo & signalInfo,
-                       Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      signalSemaphoreKHR( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo * pSignalInfo,
-                          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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
-      signalSemaphoreKHR( const SemaphoreSignalInfo & signalInfo,
-                          Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void trimCommandPool( VULKAN_HPP_NAMESPACE::CommandPool          commandPool,
-                          VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags,
-                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void trimCommandPoolKHR( VULKAN_HPP_NAMESPACE::CommandPool          commandPool,
-                             VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags,
-                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void uninitializePerformanceApiINTEL( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
-      VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void unmapMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory,
-                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void updateDescriptorSetWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorSet            descriptorSet,
-                                          VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
-                                          const void *                                   pData,
-                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
-      VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void updateDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorSet            descriptorSet,
-                                             VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
-                                             const void *                                   pData,
-                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
-      VULKAN_HPP_NOEXCEPT;
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void updateDescriptorSets( uint32_t                                         descriptorWriteCount,
-                               const VULKAN_HPP_NAMESPACE::WriteDescriptorSet * pDescriptorWrites,
-                               uint32_t                                         descriptorCopyCount,
-                               const VULKAN_HPP_NAMESPACE::CopyDescriptorSet *  pDescriptorCopies,
-                               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 updateDescriptorSets( ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites,
-                               ArrayProxy<const VULKAN_HPP_NAMESPACE::CopyDescriptorSet> const &  descriptorCopies,
-                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#if defined( VK_ENABLE_BETA_EXTENSIONS )
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result updateVideoSessionParametersKHR(
-      VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR                   videoSessionParameters,
-      const VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR * pUpdateInfo,
-      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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
-      updateVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters,
-                                       const VideoSessionParametersUpdateInfoKHR &     updateInfo,
-                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_ENABLE_BETA_EXTENSIONS*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      waitForFences( uint32_t                            fenceCount,
-                     const VULKAN_HPP_NAMESPACE::Fence * pFences,
-                     VULKAN_HPP_NAMESPACE::Bool32        waitAll,
-                     uint64_t                            timeout,
-                     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>
-    VULKAN_HPP_NODISCARD Result waitForFences( ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences,
-                                               VULKAN_HPP_NAMESPACE::Bool32                          waitAll,
-                                               uint64_t                                              timeout,
-                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      waitSemaphores( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo * pWaitInfo,
-                      uint64_t                                        timeout,
-                      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>
-    VULKAN_HPP_NODISCARD Result waitSemaphores( const SemaphoreWaitInfo & waitInfo,
-                                                uint64_t                  timeout,
-                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      waitSemaphoresKHR( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo * pWaitInfo,
-                         uint64_t                                        timeout,
-                         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>
-    VULKAN_HPP_NODISCARD Result waitSemaphoresKHR( const SemaphoreWaitInfo & waitInfo,
-                                                   uint64_t                  timeout,
-                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result writeAccelerationStructuresPropertiesKHR(
-      uint32_t                                               accelerationStructureCount,
-      const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR * pAccelerationStructures,
-      VULKAN_HPP_NAMESPACE::QueryType                        queryType,
-      size_t                                                 dataSize,
-      void *                                                 pData,
-      size_t                                                 stride,
-      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
-      writeAccelerationStructuresPropertiesKHR(
-        ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
-        VULKAN_HPP_NAMESPACE::QueryType                                          queryType,
-        ArrayProxy<T> const &                                                    data,
-        size_t                                                                   stride,
-        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename T,
-              typename Allocator = std::allocator<T>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<std::vector<T, Allocator>>::type
-      writeAccelerationStructuresPropertiesKHR(
-        ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
-        VULKAN_HPP_NAMESPACE::QueryType                                          queryType,
-        size_t                                                                   dataSize,
-        size_t                                                                   stride,
-        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<T>::type writeAccelerationStructuresPropertyKHR(
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
-      VULKAN_HPP_NAMESPACE::QueryType                                          queryType,
-      size_t                                                                   stride,
-      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDevice() const VULKAN_HPP_NOEXCEPT
     {
       return m_device;
@@ -67627,34 +67732,85 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
-#if defined( VK_USE_PLATFORM_WIN32_KHR )
-#  ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display,
-                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#  else
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
-         acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display,
-                                Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_USE_PLATFORM_WIN32_KHR*/
+    //=== VK_VERSION_1_0 ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void getFeatures( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures * pFeatures,
+                      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>
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures
+      getFeatures( 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 getFormatProperties( VULKAN_HPP_NAMESPACE::Format             format,
+                              VULKAN_HPP_NAMESPACE::FormatProperties * pFormatProperties,
+                              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>
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties
+                         getFormatProperties( VULKAN_HPP_NAMESPACE::Format format,
+                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
-#if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD Result
-      acquireXlibDisplayEXT( Display *                        dpy,
-                             VULKAN_HPP_NAMESPACE::DisplayKHR display,
-                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+      getImageFormatProperties( VULKAN_HPP_NAMESPACE::Format                  format,
+                                VULKAN_HPP_NAMESPACE::ImageType               type,
+                                VULKAN_HPP_NAMESPACE::ImageTiling             tiling,
+                                VULKAN_HPP_NAMESPACE::ImageUsageFlags         usage,
+                                VULKAN_HPP_NAMESPACE::ImageCreateFlags        flags,
+                                VULKAN_HPP_NAMESPACE::ImageFormatProperties * pImageFormatProperties,
+                                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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
-      acquireXlibDisplayEXT( Display &                        dpy,
-                             VULKAN_HPP_NAMESPACE::DisplayKHR display,
-                             Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageFormatProperties>::type
+      getImageFormatProperties( VULKAN_HPP_NAMESPACE::Format                 format,
+                                VULKAN_HPP_NAMESPACE::ImageType              type,
+                                VULKAN_HPP_NAMESPACE::ImageTiling            tiling,
+                                VULKAN_HPP_NAMESPACE::ImageUsageFlags        usage,
+                                VULKAN_HPP_NAMESPACE::ImageCreateFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
+                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void getProperties( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties * pProperties,
+                        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>
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties
+      getProperties( 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
+      getQueueFamilyProperties( uint32_t *                                    pQueueFamilyPropertyCount,
+                                VULKAN_HPP_NAMESPACE::QueueFamilyProperties * pQueueFamilyProperties,
+                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename QueueFamilyPropertiesAllocator = std::allocator<QueueFamilyProperties>,
+              typename Dispatch                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD std::vector<QueueFamilyProperties, QueueFamilyPropertiesAllocator>
+                         getQueueFamilyProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <
+      typename QueueFamilyPropertiesAllocator = std::allocator<QueueFamilyProperties>,
+      typename Dispatch                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+      typename B                              = QueueFamilyPropertiesAllocator,
+      typename std::enable_if<std::is_same<typename B::value_type, QueueFamilyProperties>::value, int>::type = 0>
+    VULKAN_HPP_NODISCARD std::vector<QueueFamilyProperties, QueueFamilyPropertiesAllocator>
+                         getQueueFamilyProperties( QueueFamilyPropertiesAllocator & queueFamilyPropertiesAllocator,
+                                                   Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void getMemoryProperties( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties * pMemoryProperties,
+                              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>
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties
+      getMemoryProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD Result
@@ -67676,33 +67832,6 @@ namespace VULKAN_HPP_NAMESPACE
                           Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      createDisplayModeKHR( VULKAN_HPP_NAMESPACE::DisplayKHR                       display,
-                            const VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR * pCreateInfo,
-                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks *      pAllocator,
-                            VULKAN_HPP_NAMESPACE::DisplayModeKHR *                 pMode,
-                            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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayModeKHR>::type
-      createDisplayModeKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display,
-                            const DisplayModeCreateInfoKHR & createInfo,
-                            Optional<const AllocationCallbacks> allocator
-                                               VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayModeKHR, Dispatch>>::type
-      createDisplayModeKHRUnique( VULKAN_HPP_NAMESPACE::DisplayKHR display,
-                                  const DisplayModeCreateInfoKHR & createInfo,
-                                  Optional<const AllocationCallbacks> allocator
-                                                     VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -67747,6 +67876,801 @@ namespace VULKAN_HPP_NAMESPACE
                                       Dispatch const & d         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format                        format,
+                                         VULKAN_HPP_NAMESPACE::ImageType                     type,
+                                         VULKAN_HPP_NAMESPACE::SampleCountFlagBits           samples,
+                                         VULKAN_HPP_NAMESPACE::ImageUsageFlags               usage,
+                                         VULKAN_HPP_NAMESPACE::ImageTiling                   tiling,
+                                         uint32_t *                                          pPropertyCount,
+                                         VULKAN_HPP_NAMESPACE::SparseImageFormatProperties * pProperties,
+                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
+      VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename SparseImageFormatPropertiesAllocator = std::allocator<SparseImageFormatProperties>,
+              typename Dispatch                             = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD std::vector<SparseImageFormatProperties, SparseImageFormatPropertiesAllocator>
+                         getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format              format,
+                                                         VULKAN_HPP_NAMESPACE::ImageType           type,
+                                                         VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,
+                                                         VULKAN_HPP_NAMESPACE::ImageUsageFlags     usage,
+                                                         VULKAN_HPP_NAMESPACE::ImageTiling         tiling,
+                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <
+      typename SparseImageFormatPropertiesAllocator = std::allocator<SparseImageFormatProperties>,
+      typename Dispatch                             = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+      typename B                                    = SparseImageFormatPropertiesAllocator,
+      typename std::enable_if<std::is_same<typename B::value_type, SparseImageFormatProperties>::value, int>::type = 0>
+    VULKAN_HPP_NODISCARD std::vector<SparseImageFormatProperties, SparseImageFormatPropertiesAllocator>
+                         getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format              format,
+                                                         VULKAN_HPP_NAMESPACE::ImageType           type,
+                                                         VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,
+                                                         VULKAN_HPP_NAMESPACE::ImageUsageFlags     usage,
+                                                         VULKAN_HPP_NAMESPACE::ImageTiling         tiling,
+                                                         SparseImageFormatPropertiesAllocator &    sparseImageFormatPropertiesAllocator,
+                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    //=== VK_VERSION_1_1 ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void getFeatures2( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 * pFeatures,
+                       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>
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2
+      getFeatures2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
+      getFeatures2( 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 getProperties2( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 * pProperties,
+                         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>
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2
+      getProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
+      getProperties2( 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 getFormatProperties2( VULKAN_HPP_NAMESPACE::Format              format,
+                               VULKAN_HPP_NAMESPACE::FormatProperties2 * pFormatProperties,
+                               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>
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties2
+                         getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format,
+                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
+                         getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format,
+                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result getImageFormatProperties2(
+      const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 * pImageFormatInfo,
+      VULKAN_HPP_NAMESPACE::ImageFormatProperties2 *               pImageFormatProperties,
+      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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>::type
+      getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo,
+                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<StructureChain<X, Y, Z...>>::type
+      getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo,
+                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void getQueueFamilyProperties2( uint32_t *                                     pQueueFamilyPropertyCount,
+                                    VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 * pQueueFamilyProperties,
+                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
+      VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename QueueFamilyProperties2Allocator = std::allocator<QueueFamilyProperties2>,
+              typename Dispatch                        = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator>
+                         getQueueFamilyProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <
+      typename QueueFamilyProperties2Allocator = std::allocator<QueueFamilyProperties2>,
+      typename Dispatch                        = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+      typename B                               = QueueFamilyProperties2Allocator,
+      typename std::enable_if<std::is_same<typename B::value_type, QueueFamilyProperties2>::value, int>::type = 0>
+    VULKAN_HPP_NODISCARD std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator>
+                         getQueueFamilyProperties2( QueueFamilyProperties2Allocator & queueFamilyProperties2Allocator,
+                                                    Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <typename StructureChain,
+              typename StructureChainAllocator = std::allocator<StructureChain>,
+              typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>
+                         getQueueFamilyProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <typename StructureChain,
+              typename StructureChainAllocator = std::allocator<StructureChain>,
+              typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B                       = StructureChainAllocator,
+              typename std::enable_if<std::is_same<typename B::value_type, StructureChain>::value, int>::type = 0>
+    VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>
+                         getQueueFamilyProperties2( StructureChainAllocator & structureChainAllocator,
+                                                    Dispatch const & d        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void getMemoryProperties2( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 * pMemoryProperties,
+                               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>
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2
+      getMemoryProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
+      getMemoryProperties2( 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 getSparseImageFormatProperties2(
+      const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,
+      uint32_t *                                                         pPropertyCount,
+      VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 *               pProperties,
+      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename SparseImageFormatProperties2Allocator = std::allocator<SparseImageFormatProperties2>,
+              typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
+                         getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
+                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <
+      typename SparseImageFormatProperties2Allocator = std::allocator<SparseImageFormatProperties2>,
+      typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+      typename B                                     = SparseImageFormatProperties2Allocator,
+      typename std::enable_if<std::is_same<typename B::value_type, SparseImageFormatProperties2>::value, int>::type = 0>
+    VULKAN_HPP_NODISCARD std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
+                         getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
+                                                          SparseImageFormatProperties2Allocator & sparseImageFormatProperties2Allocator,
+                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void getExternalBufferProperties(
+      const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo * pExternalBufferInfo,
+      VULKAN_HPP_NAMESPACE::ExternalBufferProperties *               pExternalBufferProperties,
+      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>
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalBufferProperties getExternalBufferProperties(
+      const PhysicalDeviceExternalBufferInfo & externalBufferInfo,
+      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 getExternalFenceProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo * pExternalFenceInfo,
+                                     VULKAN_HPP_NAMESPACE::ExternalFenceProperties * pExternalFenceProperties,
+                                     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>
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalFenceProperties getExternalFenceProperties(
+      const PhysicalDeviceExternalFenceInfo & externalFenceInfo,
+      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 getExternalSemaphoreProperties(
+      const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,
+      VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties *               pExternalSemaphoreProperties,
+      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>
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties getExternalSemaphoreProperties(
+      const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo,
+      Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    //=== VK_KHR_surface ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      getSurfaceSupportKHR( uint32_t                         queueFamilyIndex,
+                            VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
+                            VULKAN_HPP_NAMESPACE::Bool32 *   pSupported,
+                            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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::Bool32>::type
+      getSurfaceSupportKHR( uint32_t                         queueFamilyIndex,
+                            VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
+                            Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result getSurfaceCapabilitiesKHR(
+      VULKAN_HPP_NAMESPACE::SurfaceKHR               surface,
+      VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR * pSurfaceCapabilities,
+      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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR>::type
+      getSurfaceCapabilitiesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
+                                 Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR         surface,
+                            uint32_t *                               pSurfaceFormatCount,
+                            VULKAN_HPP_NAMESPACE::SurfaceFormatKHR * pSurfaceFormats,
+                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename SurfaceFormatKHRAllocator = std::allocator<SurfaceFormatKHR>,
+              typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<SurfaceFormatKHR, SurfaceFormatKHRAllocator>>::type
+      getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
+                            Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <typename SurfaceFormatKHRAllocator = std::allocator<SurfaceFormatKHR>,
+              typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B                         = SurfaceFormatKHRAllocator,
+              typename std::enable_if<std::is_same<typename B::value_type, SurfaceFormatKHR>::value, int>::type = 0>
+    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<SurfaceFormatKHR, SurfaceFormatKHRAllocator>>::type
+      getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
+                            SurfaceFormatKHRAllocator &      surfaceFormatKHRAllocator,
+                            Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result getSurfacePresentModesKHR(
+      VULKAN_HPP_NAMESPACE::SurfaceKHR       surface,
+      uint32_t *                             pPresentModeCount,
+      VULKAN_HPP_NAMESPACE::PresentModeKHR * pPresentModes,
+      Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename PresentModeKHRAllocator = std::allocator<PresentModeKHR>,
+              typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PresentModeKHR, PresentModeKHRAllocator>>::type
+      getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
+                                 Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <typename PresentModeKHRAllocator = std::allocator<PresentModeKHR>,
+              typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B                       = PresentModeKHRAllocator,
+              typename std::enable_if<std::is_same<typename B::value_type, PresentModeKHR>::value, int>::type = 0>
+    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PresentModeKHR, PresentModeKHRAllocator>>::type
+      getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
+                                 PresentModeKHRAllocator &        presentModeKHRAllocator,
+                                 Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    //=== VK_KHR_swapchain ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
+                               uint32_t *                       pRectCount,
+                               VULKAN_HPP_NAMESPACE::Rect2D *   pRects,
+                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename Rect2DAllocator = std::allocator<Rect2D>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<Rect2D, Rect2DAllocator>>::type
+      getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
+                               Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <typename Rect2DAllocator = std::allocator<Rect2D>,
+              typename Dispatch        = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B               = Rect2DAllocator,
+              typename std::enable_if<std::is_same<typename B::value_type, Rect2D>::value, int>::type = 0>
+    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<Rect2D, Rect2DAllocator>>::type
+      getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
+                               Rect2DAllocator &                rect2DAllocator,
+                               Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    //=== VK_KHR_display ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      getDisplayPropertiesKHR( uint32_t *                                   pPropertyCount,
+                               VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR * pProperties,
+                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename DisplayPropertiesKHRAllocator = std::allocator<DisplayPropertiesKHR>,
+              typename Dispatch                      = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD
+      typename ResultValueType<std::vector<DisplayPropertiesKHR, DisplayPropertiesKHRAllocator>>::type
+      getDisplayPropertiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <typename DisplayPropertiesKHRAllocator = std::allocator<DisplayPropertiesKHR>,
+              typename Dispatch                      = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B                             = DisplayPropertiesKHRAllocator,
+              typename std::enable_if<std::is_same<typename B::value_type, DisplayPropertiesKHR>::value, int>::type = 0>
+    VULKAN_HPP_NODISCARD
+      typename ResultValueType<std::vector<DisplayPropertiesKHR, DisplayPropertiesKHRAllocator>>::type
+      getDisplayPropertiesKHR( DisplayPropertiesKHRAllocator & displayPropertiesKHRAllocator,
+                               Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result getDisplayPlanePropertiesKHR(
+      uint32_t *                                        pPropertyCount,
+      VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR * pProperties,
+      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename DisplayPlanePropertiesKHRAllocator = std::allocator<DisplayPlanePropertiesKHR>,
+              typename Dispatch                           = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD
+      typename ResultValueType<std::vector<DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator>>::type
+      getDisplayPlanePropertiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <
+      typename DisplayPlanePropertiesKHRAllocator = std::allocator<DisplayPlanePropertiesKHR>,
+      typename Dispatch                           = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+      typename B                                  = DisplayPlanePropertiesKHRAllocator,
+      typename std::enable_if<std::is_same<typename B::value_type, DisplayPlanePropertiesKHR>::value, int>::type = 0>
+    VULKAN_HPP_NODISCARD
+      typename ResultValueType<std::vector<DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator>>::type
+      getDisplayPlanePropertiesKHR( DisplayPlanePropertiesKHRAllocator & displayPlanePropertiesKHRAllocator,
+                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result getDisplayPlaneSupportedDisplaysKHR(
+      uint32_t                           planeIndex,
+      uint32_t *                         pDisplayCount,
+      VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplays,
+      Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename DisplayKHRAllocator = std::allocator<DisplayKHR>,
+              typename Dispatch            = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayKHR, DisplayKHRAllocator>>::type
+      getDisplayPlaneSupportedDisplaysKHR( uint32_t           planeIndex,
+                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <typename DisplayKHRAllocator = std::allocator<DisplayKHR>,
+              typename Dispatch            = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B                   = DisplayKHRAllocator,
+              typename std::enable_if<std::is_same<typename B::value_type, DisplayKHR>::value, int>::type = 0>
+    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayKHR, DisplayKHRAllocator>>::type
+      getDisplayPlaneSupportedDisplaysKHR( uint32_t              planeIndex,
+                                           DisplayKHRAllocator & displayKHRAllocator,
+                                           Dispatch const & d    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result getDisplayModePropertiesKHR(
+      VULKAN_HPP_NAMESPACE::DisplayKHR                 display,
+      uint32_t *                                       pPropertyCount,
+      VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR * pProperties,
+      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename DisplayModePropertiesKHRAllocator = std::allocator<DisplayModePropertiesKHR>,
+              typename Dispatch                          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD
+      typename ResultValueType<std::vector<DisplayModePropertiesKHR, DisplayModePropertiesKHRAllocator>>::type
+      getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display,
+                                   Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <
+      typename DisplayModePropertiesKHRAllocator = std::allocator<DisplayModePropertiesKHR>,
+      typename Dispatch                          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+      typename B                                 = DisplayModePropertiesKHRAllocator,
+      typename std::enable_if<std::is_same<typename B::value_type, DisplayModePropertiesKHR>::value, int>::type = 0>
+    VULKAN_HPP_NODISCARD
+      typename ResultValueType<std::vector<DisplayModePropertiesKHR, DisplayModePropertiesKHRAllocator>>::type
+      getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR    display,
+                                   DisplayModePropertiesKHRAllocator & displayModePropertiesKHRAllocator,
+                                   Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      createDisplayModeKHR( VULKAN_HPP_NAMESPACE::DisplayKHR                       display,
+                            const VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR * pCreateInfo,
+                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks *      pAllocator,
+                            VULKAN_HPP_NAMESPACE::DisplayModeKHR *                 pMode,
+                            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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayModeKHR>::type
+      createDisplayModeKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display,
+                            const DisplayModeCreateInfoKHR & createInfo,
+                            Optional<const AllocationCallbacks> allocator
+                                               VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayModeKHR, Dispatch>>::type
+      createDisplayModeKHRUnique( VULKAN_HPP_NAMESPACE::DisplayKHR display,
+                                  const DisplayModeCreateInfoKHR & createInfo,
+                                  Optional<const AllocationCallbacks> allocator
+                                                     VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result getDisplayPlaneCapabilitiesKHR(
+      VULKAN_HPP_NAMESPACE::DisplayModeKHR                mode,
+      uint32_t                                            planeIndex,
+      VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR * pCapabilities,
+      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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
+      typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR>::type
+      getDisplayPlaneCapabilitiesKHR( VULKAN_HPP_NAMESPACE::DisplayModeKHR mode,
+                                      uint32_t                             planeIndex,
+                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#if defined( VK_USE_PLATFORM_XLIB_KHR )
+    //=== VK_KHR_xlib_surface ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    Bool32 getXlibPresentationSupportKHR( uint32_t           queueFamilyIndex,
+                                          Display *          dpy,
+                                          VisualID           visualID,
+                                          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>
+    Bool32 getXlibPresentationSupportKHR( uint32_t           queueFamilyIndex,
+                                          Display &          dpy,
+                                          VisualID           visualID,
+                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
+      VULKAN_HPP_NOEXCEPT;
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VK_USE_PLATFORM_XLIB_KHR*/
+
+#if defined( VK_USE_PLATFORM_XCB_KHR )
+    //=== VK_KHR_xcb_surface ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    Bool32 getXcbPresentationSupportKHR( uint32_t           queueFamilyIndex,
+                                         xcb_connection_t * connection,
+                                         xcb_visualid_t     visual_id,
+                                         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>
+    Bool32 getXcbPresentationSupportKHR( uint32_t           queueFamilyIndex,
+                                         xcb_connection_t & connection,
+                                         xcb_visualid_t     visual_id,
+                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
+      VULKAN_HPP_NOEXCEPT;
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VK_USE_PLATFORM_XCB_KHR*/
+
+#if defined( VK_USE_PLATFORM_WAYLAND_KHR )
+    //=== VK_KHR_wayland_surface ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    Bool32 getWaylandPresentationSupportKHR( uint32_t            queueFamilyIndex,
+                                             struct wl_display * display,
+                                             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>
+    Bool32 getWaylandPresentationSupportKHR( uint32_t            queueFamilyIndex,
+                                             struct wl_display & display,
+                                             Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
+      VULKAN_HPP_NOEXCEPT;
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VK_USE_PLATFORM_WAYLAND_KHR*/
+
+#if defined( VK_USE_PLATFORM_WIN32_KHR )
+    //=== VK_KHR_win32_surface ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    Bool32 getWin32PresentationSupportKHR( uint32_t           queueFamilyIndex,
+                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
+      VULKAN_HPP_NOEXCEPT;
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+#if defined( VK_ENABLE_BETA_EXTENSIONS )
+    //=== VK_KHR_video_queue ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileKHR * pVideoProfile,
+                               VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR *  pCapabilities,
+                               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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR>::type
+      getVideoCapabilitiesKHR( const VideoProfileKHR & videoProfile,
+                               Dispatch const & d      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<StructureChain<X, Y, Z...>>::type
+      getVideoCapabilitiesKHR( const VideoProfileKHR & videoProfile,
+                               Dispatch const & d      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result getVideoFormatPropertiesKHR(
+      const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR * pVideoFormatInfo,
+      uint32_t *                                                     pVideoFormatPropertyCount,
+      VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR *               pVideoFormatProperties,
+      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename VideoFormatPropertiesKHRAllocator = std::allocator<VideoFormatPropertiesKHR>,
+              typename Dispatch                          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD
+      typename ResultValueType<std::vector<VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator>>::type
+      getVideoFormatPropertiesKHR( const PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo,
+                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <
+      typename VideoFormatPropertiesKHRAllocator = std::allocator<VideoFormatPropertiesKHR>,
+      typename Dispatch                          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+      typename B                                 = VideoFormatPropertiesKHRAllocator,
+      typename std::enable_if<std::is_same<typename B::value_type, VideoFormatPropertiesKHR>::value, int>::type = 0>
+    VULKAN_HPP_NODISCARD
+      typename ResultValueType<std::vector<VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator>>::type
+      getVideoFormatPropertiesKHR( const PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo,
+                                   VideoFormatPropertiesKHRAllocator &      videoFormatPropertiesKHRAllocator,
+                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VK_ENABLE_BETA_EXTENSIONS*/
+
+    //=== VK_NV_external_memory_capabilities ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result getExternalImageFormatPropertiesNV(
+      VULKAN_HPP_NAMESPACE::Format                            format,
+      VULKAN_HPP_NAMESPACE::ImageType                         type,
+      VULKAN_HPP_NAMESPACE::ImageTiling                       tiling,
+      VULKAN_HPP_NAMESPACE::ImageUsageFlags                   usage,
+      VULKAN_HPP_NAMESPACE::ImageCreateFlags                  flags,
+      VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV   externalHandleType,
+      VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV * pExternalImageFormatProperties,
+      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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
+      typename ResultValueType<VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV>::type
+      getExternalImageFormatPropertiesNV(
+        VULKAN_HPP_NAMESPACE::Format                                             format,
+        VULKAN_HPP_NAMESPACE::ImageType                                          type,
+        VULKAN_HPP_NAMESPACE::ImageTiling                                        tiling,
+        VULKAN_HPP_NAMESPACE::ImageUsageFlags                                    usage,
+        VULKAN_HPP_NAMESPACE::ImageCreateFlags flags                             VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
+        VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV externalHandleType VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
+        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    //=== VK_KHR_get_physical_device_properties2 ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void getFeatures2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 * pFeatures,
+                          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>
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2
+      getFeatures2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
+      getFeatures2KHR( 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 getProperties2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 * pProperties,
+                            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>
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2
+      getProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
+      getProperties2KHR( 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
+      getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format              format,
+                               VULKAN_HPP_NAMESPACE::FormatProperties2 * pFormatProperties,
+                               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>
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties2
+                         getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format,
+                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
+                         getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format,
+                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result getImageFormatProperties2KHR(
+      const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 * pImageFormatInfo,
+      VULKAN_HPP_NAMESPACE::ImageFormatProperties2 *               pImageFormatProperties,
+      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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>::type
+      getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo,
+                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<StructureChain<X, Y, Z...>>::type
+      getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo,
+                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void getQueueFamilyProperties2KHR( uint32_t *                                     pQueueFamilyPropertyCount,
+                                       VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 * pQueueFamilyProperties,
+                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
+      VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename QueueFamilyProperties2Allocator = std::allocator<QueueFamilyProperties2>,
+              typename Dispatch                        = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator>
+      getQueueFamilyProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <
+      typename QueueFamilyProperties2Allocator = std::allocator<QueueFamilyProperties2>,
+      typename Dispatch                        = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+      typename B                               = QueueFamilyProperties2Allocator,
+      typename std::enable_if<std::is_same<typename B::value_type, QueueFamilyProperties2>::value, int>::type = 0>
+    VULKAN_HPP_NODISCARD std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator>
+      getQueueFamilyProperties2KHR( QueueFamilyProperties2Allocator & queueFamilyProperties2Allocator,
+                                    Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <typename StructureChain,
+              typename StructureChainAllocator = std::allocator<StructureChain>,
+              typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>
+      getQueueFamilyProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <typename StructureChain,
+              typename StructureChainAllocator = std::allocator<StructureChain>,
+              typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B                       = StructureChainAllocator,
+              typename std::enable_if<std::is_same<typename B::value_type, StructureChain>::value, int>::type = 0>
+    VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>
+                         getQueueFamilyProperties2KHR( StructureChainAllocator & structureChainAllocator,
+                                                       Dispatch const & d        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void
+      getMemoryProperties2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 * pMemoryProperties,
+                               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>
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2
+      getMemoryProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
+      getMemoryProperties2KHR( 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 getSparseImageFormatProperties2KHR(
+      const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,
+      uint32_t *                                                         pPropertyCount,
+      VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 *               pProperties,
+      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename SparseImageFormatProperties2Allocator = std::allocator<SparseImageFormatProperties2>,
+              typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
+                         getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
+                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <
+      typename SparseImageFormatProperties2Allocator = std::allocator<SparseImageFormatProperties2>,
+      typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+      typename B                                     = SparseImageFormatProperties2Allocator,
+      typename std::enable_if<std::is_same<typename B::value_type, SparseImageFormatProperties2>::value, int>::type = 0>
+    VULKAN_HPP_NODISCARD std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
+                         getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
+                                                             SparseImageFormatProperties2Allocator & sparseImageFormatProperties2Allocator,
+                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    //=== VK_KHR_external_memory_capabilities ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void getExternalBufferPropertiesKHR(
+      const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo * pExternalBufferInfo,
+      VULKAN_HPP_NAMESPACE::ExternalBufferProperties *               pExternalBufferProperties,
+      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>
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalBufferProperties getExternalBufferPropertiesKHR(
+      const PhysicalDeviceExternalBufferInfo & externalBufferInfo,
+      Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    //=== VK_KHR_external_semaphore_capabilities ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void getExternalSemaphorePropertiesKHR(
+      const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,
+      VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties *               pExternalSemaphoreProperties,
+      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>
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties getExternalSemaphorePropertiesKHR(
+      const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo,
+      Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    //=== VK_EXT_direct_mode_display ===
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    Result releaseDisplayEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display,
+                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#else
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    typename ResultValueType<void>::type
+         releaseDisplayEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display,
+                            Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
+    //=== VK_EXT_acquire_xlib_display ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      acquireXlibDisplayEXT( Display *                        dpy,
+                             VULKAN_HPP_NAMESPACE::DisplayKHR display,
+                             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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
+      acquireXlibDisplayEXT( Display &                        dpy,
+                             VULKAN_HPP_NAMESPACE::DisplayKHR display,
+                             Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      getRandROutputDisplayEXT( Display *                          dpy,
+                                RROutput                           rrOutput,
+                                VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplay,
+                                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>
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type getRandROutputDisplayEXT(
+      Display & dpy, RROutput rrOutput, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#    ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type
+      getRandROutputDisplayEXTUnique( Display &          dpy,
+                                      RROutput           rrOutput,
+                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif     /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
+
+    //=== VK_EXT_display_surface_counter ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result getSurfaceCapabilities2EXT(
+      VULKAN_HPP_NAMESPACE::SurfaceKHR                surface,
+      VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT * pSurfaceCapabilities,
+      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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
+      typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT>::type
+      getSurfaceCapabilities2EXT( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
+                                  Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    //=== VK_KHR_external_fence_capabilities ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void getExternalFencePropertiesKHR(
+      const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo * pExternalFenceInfo,
+      VULKAN_HPP_NAMESPACE::ExternalFenceProperties *               pExternalFenceProperties,
+      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>
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalFenceProperties getExternalFencePropertiesKHR(
+      const PhysicalDeviceExternalFenceInfo & externalFenceInfo,
+      Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    //=== VK_KHR_performance_query ===
+
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD Result enumerateQueueFamilyPerformanceQueryCountersKHR(
       uint32_t                                                 queueFamilyIndex,
@@ -67799,6 +68723,105 @@ namespace VULKAN_HPP_NAMESPACE
         Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void getQueueFamilyPerformanceQueryPassesKHR(
+      const VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR * pPerformanceQueryCreateInfo,
+      uint32_t *                                                      pNumPasses,
+      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>
+    VULKAN_HPP_NODISCARD uint32_t getQueueFamilyPerformanceQueryPassesKHR(
+      const QueryPoolPerformanceCreateInfoKHR & performanceQueryCreateInfo,
+      Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    //=== VK_KHR_get_surface_capabilities2 ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result getSurfaceCapabilities2KHR(
+      const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
+      VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR *             pSurfaceCapabilities,
+      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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
+      typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR>::type
+      getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
+                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<StructureChain<X, Y, Z...>>::type
+      getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
+                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
+                             uint32_t *                                                  pSurfaceFormatCount,
+                             VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR *                   pSurfaceFormats,
+                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename SurfaceFormat2KHRAllocator = std::allocator<SurfaceFormat2KHR>,
+              typename Dispatch                   = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<SurfaceFormat2KHR, SurfaceFormat2KHRAllocator>>::type
+      getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
+                             Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <typename SurfaceFormat2KHRAllocator = std::allocator<SurfaceFormat2KHR>,
+              typename Dispatch                   = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B                          = SurfaceFormat2KHRAllocator,
+              typename std::enable_if<std::is_same<typename B::value_type, SurfaceFormat2KHR>::value, int>::type = 0>
+    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<SurfaceFormat2KHR, SurfaceFormat2KHRAllocator>>::type
+      getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
+                             SurfaceFormat2KHRAllocator &          surfaceFormat2KHRAllocator,
+                             Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    //=== VK_KHR_get_display_properties2 ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      getDisplayProperties2KHR( uint32_t *                                    pPropertyCount,
+                                VULKAN_HPP_NAMESPACE::DisplayProperties2KHR * pProperties,
+                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename DisplayProperties2KHRAllocator = std::allocator<DisplayProperties2KHR>,
+              typename Dispatch                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD
+      typename ResultValueType<std::vector<DisplayProperties2KHR, DisplayProperties2KHRAllocator>>::type
+      getDisplayProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <
+      typename DisplayProperties2KHRAllocator = std::allocator<DisplayProperties2KHR>,
+      typename Dispatch                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+      typename B                              = DisplayProperties2KHRAllocator,
+      typename std::enable_if<std::is_same<typename B::value_type, DisplayProperties2KHR>::value, int>::type = 0>
+    VULKAN_HPP_NODISCARD
+      typename ResultValueType<std::vector<DisplayProperties2KHR, DisplayProperties2KHRAllocator>>::type
+      getDisplayProperties2KHR( DisplayProperties2KHRAllocator & displayProperties2KHRAllocator,
+                                Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result getDisplayPlaneProperties2KHR(
+      uint32_t *                                         pPropertyCount,
+      VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR * pProperties,
+      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename DisplayPlaneProperties2KHRAllocator = std::allocator<DisplayPlaneProperties2KHR>,
+              typename Dispatch                            = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD
+      typename ResultValueType<std::vector<DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator>>::type
+      getDisplayPlaneProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <
+      typename DisplayPlaneProperties2KHRAllocator = std::allocator<DisplayPlaneProperties2KHR>,
+      typename Dispatch                            = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+      typename B                                   = DisplayPlaneProperties2KHRAllocator,
+      typename std::enable_if<std::is_same<typename B::value_type, DisplayPlaneProperties2KHR>::value, int>::type = 0>
+    VULKAN_HPP_NODISCARD
+      typename ResultValueType<std::vector<DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator>>::type
+      getDisplayPlaneProperties2KHR( DisplayPlaneProperties2KHRAllocator & displayPlaneProperties2KHRAllocator,
+                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD Result getDisplayModeProperties2KHR(
       VULKAN_HPP_NAMESPACE::DisplayKHR                  display,
@@ -67824,31 +68847,6 @@ namespace VULKAN_HPP_NAMESPACE
                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result getDisplayModePropertiesKHR(
-      VULKAN_HPP_NAMESPACE::DisplayKHR                 display,
-      uint32_t *                                       pPropertyCount,
-      VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR * pProperties,
-      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename DisplayModePropertiesKHRAllocator = std::allocator<DisplayModePropertiesKHR>,
-              typename Dispatch                          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD
-      typename ResultValueType<std::vector<DisplayModePropertiesKHR, DisplayModePropertiesKHRAllocator>>::type
-      getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display,
-                                   Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <
-      typename DisplayModePropertiesKHRAllocator = std::allocator<DisplayModePropertiesKHR>,
-      typename Dispatch                          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-      typename B                                 = DisplayModePropertiesKHRAllocator,
-      typename std::enable_if<std::is_same<typename B::value_type, DisplayModePropertiesKHR>::value, int>::type = 0>
-    VULKAN_HPP_NODISCARD
-      typename ResultValueType<std::vector<DisplayModePropertiesKHR, DisplayModePropertiesKHRAllocator>>::type
-      getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR    display,
-                                   DisplayModePropertiesKHRAllocator & displayModePropertiesKHRAllocator,
-                                   Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD Result getDisplayPlaneCapabilities2KHR(
       const VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR *   pDisplayPlaneInfo,
@@ -67862,43 +68860,22 @@ namespace VULKAN_HPP_NAMESPACE
                                        Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result getDisplayPlaneCapabilitiesKHR(
-      VULKAN_HPP_NAMESPACE::DisplayModeKHR                mode,
-      uint32_t                                            planeIndex,
-      VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR * pCapabilities,
-      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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
-      typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR>::type
-      getDisplayPlaneCapabilitiesKHR( VULKAN_HPP_NAMESPACE::DisplayModeKHR mode,
-                                      uint32_t                             planeIndex,
-                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+    //=== VK_EXT_sample_locations ===
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result getDisplayPlaneSupportedDisplaysKHR(
-      uint32_t                           planeIndex,
-      uint32_t *                         pDisplayCount,
-      VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplays,
-      Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+    void getMultisamplePropertiesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits        samples,
+                                      VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT * pMultisampleProperties,
+                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
+      VULKAN_HPP_NOEXCEPT;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename DisplayKHRAllocator = std::allocator<DisplayKHR>,
-              typename Dispatch            = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayKHR, DisplayKHRAllocator>>::type
-      getDisplayPlaneSupportedDisplaysKHR( uint32_t           planeIndex,
-                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename DisplayKHRAllocator = std::allocator<DisplayKHR>,
-              typename Dispatch            = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B                   = DisplayKHRAllocator,
-              typename std::enable_if<std::is_same<typename B::value_type, DisplayKHR>::value, int>::type = 0>
-    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayKHR, DisplayKHRAllocator>>::type
-      getDisplayPlaneSupportedDisplaysKHR( uint32_t              planeIndex,
-                                           DisplayKHRAllocator & displayKHRAllocator,
-                                           Dispatch const & d    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT getMultisamplePropertiesEXT(
+      VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,
+      Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+    //=== VK_EXT_calibrated_timestamps ===
+
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD Result getCalibrateableTimeDomainsEXT(
       uint32_t *                            pTimeDomainCount,
@@ -67918,300 +68895,7 @@ namespace VULKAN_HPP_NAMESPACE
                                       Dispatch const & d       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result getCooperativeMatrixPropertiesNV(
-      uint32_t *                                            pPropertyCount,
-      VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV * pProperties,
-      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename CooperativeMatrixPropertiesNVAllocator = std::allocator<CooperativeMatrixPropertiesNV>,
-              typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD
-      typename ResultValueType<std::vector<CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator>>::type
-      getCooperativeMatrixPropertiesNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename CooperativeMatrixPropertiesNVAllocator = std::allocator<CooperativeMatrixPropertiesNV>,
-              typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B                                      = CooperativeMatrixPropertiesNVAllocator,
-              typename std::enable_if<std::is_same<typename B::value_type, CooperativeMatrixPropertiesNV>::value,
-                                      int>::type              = 0>
-    VULKAN_HPP_NODISCARD
-      typename ResultValueType<std::vector<CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator>>::type
-      getCooperativeMatrixPropertiesNV( CooperativeMatrixPropertiesNVAllocator & cooperativeMatrixPropertiesNVAllocator,
-                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    Bool32 getDirectFBPresentationSupportEXT( uint32_t           queueFamilyIndex,
-                                              IDirectFB *        dfb,
-                                              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>
-    Bool32 getDirectFBPresentationSupportEXT( uint32_t           queueFamilyIndex,
-                                              IDirectFB &        dfb,
-                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
-      VULKAN_HPP_NOEXCEPT;
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_USE_PLATFORM_DIRECTFB_EXT*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result getDisplayPlaneProperties2KHR(
-      uint32_t *                                         pPropertyCount,
-      VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR * pProperties,
-      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename DisplayPlaneProperties2KHRAllocator = std::allocator<DisplayPlaneProperties2KHR>,
-              typename Dispatch                            = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD
-      typename ResultValueType<std::vector<DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator>>::type
-      getDisplayPlaneProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <
-      typename DisplayPlaneProperties2KHRAllocator = std::allocator<DisplayPlaneProperties2KHR>,
-      typename Dispatch                            = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-      typename B                                   = DisplayPlaneProperties2KHRAllocator,
-      typename std::enable_if<std::is_same<typename B::value_type, DisplayPlaneProperties2KHR>::value, int>::type = 0>
-    VULKAN_HPP_NODISCARD
-      typename ResultValueType<std::vector<DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator>>::type
-      getDisplayPlaneProperties2KHR( DisplayPlaneProperties2KHRAllocator & displayPlaneProperties2KHRAllocator,
-                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result getDisplayPlanePropertiesKHR(
-      uint32_t *                                        pPropertyCount,
-      VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR * pProperties,
-      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename DisplayPlanePropertiesKHRAllocator = std::allocator<DisplayPlanePropertiesKHR>,
-              typename Dispatch                           = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD
-      typename ResultValueType<std::vector<DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator>>::type
-      getDisplayPlanePropertiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <
-      typename DisplayPlanePropertiesKHRAllocator = std::allocator<DisplayPlanePropertiesKHR>,
-      typename Dispatch                           = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-      typename B                                  = DisplayPlanePropertiesKHRAllocator,
-      typename std::enable_if<std::is_same<typename B::value_type, DisplayPlanePropertiesKHR>::value, int>::type = 0>
-    VULKAN_HPP_NODISCARD
-      typename ResultValueType<std::vector<DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator>>::type
-      getDisplayPlanePropertiesKHR( DisplayPlanePropertiesKHRAllocator & displayPlanePropertiesKHRAllocator,
-                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      getDisplayProperties2KHR( uint32_t *                                    pPropertyCount,
-                                VULKAN_HPP_NAMESPACE::DisplayProperties2KHR * pProperties,
-                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename DisplayProperties2KHRAllocator = std::allocator<DisplayProperties2KHR>,
-              typename Dispatch                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD
-      typename ResultValueType<std::vector<DisplayProperties2KHR, DisplayProperties2KHRAllocator>>::type
-      getDisplayProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <
-      typename DisplayProperties2KHRAllocator = std::allocator<DisplayProperties2KHR>,
-      typename Dispatch                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-      typename B                              = DisplayProperties2KHRAllocator,
-      typename std::enable_if<std::is_same<typename B::value_type, DisplayProperties2KHR>::value, int>::type = 0>
-    VULKAN_HPP_NODISCARD
-      typename ResultValueType<std::vector<DisplayProperties2KHR, DisplayProperties2KHRAllocator>>::type
-      getDisplayProperties2KHR( DisplayProperties2KHRAllocator & displayProperties2KHRAllocator,
-                                Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      getDisplayPropertiesKHR( uint32_t *                                   pPropertyCount,
-                               VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR * pProperties,
-                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename DisplayPropertiesKHRAllocator = std::allocator<DisplayPropertiesKHR>,
-              typename Dispatch                      = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD
-      typename ResultValueType<std::vector<DisplayPropertiesKHR, DisplayPropertiesKHRAllocator>>::type
-      getDisplayPropertiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename DisplayPropertiesKHRAllocator = std::allocator<DisplayPropertiesKHR>,
-              typename Dispatch                      = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B                             = DisplayPropertiesKHRAllocator,
-              typename std::enable_if<std::is_same<typename B::value_type, DisplayPropertiesKHR>::value, int>::type = 0>
-    VULKAN_HPP_NODISCARD
-      typename ResultValueType<std::vector<DisplayPropertiesKHR, DisplayPropertiesKHRAllocator>>::type
-      getDisplayPropertiesKHR( DisplayPropertiesKHRAllocator & displayPropertiesKHRAllocator,
-                               Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void getExternalBufferProperties(
-      const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo * pExternalBufferInfo,
-      VULKAN_HPP_NAMESPACE::ExternalBufferProperties *               pExternalBufferProperties,
-      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>
-    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalBufferProperties getExternalBufferProperties(
-      const PhysicalDeviceExternalBufferInfo & externalBufferInfo,
-      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 getExternalBufferPropertiesKHR(
-      const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo * pExternalBufferInfo,
-      VULKAN_HPP_NAMESPACE::ExternalBufferProperties *               pExternalBufferProperties,
-      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>
-    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalBufferProperties getExternalBufferPropertiesKHR(
-      const PhysicalDeviceExternalBufferInfo & externalBufferInfo,
-      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 getExternalFenceProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo * pExternalFenceInfo,
-                                     VULKAN_HPP_NAMESPACE::ExternalFenceProperties * pExternalFenceProperties,
-                                     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>
-    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalFenceProperties getExternalFenceProperties(
-      const PhysicalDeviceExternalFenceInfo & externalFenceInfo,
-      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 getExternalFencePropertiesKHR(
-      const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo * pExternalFenceInfo,
-      VULKAN_HPP_NAMESPACE::ExternalFenceProperties *               pExternalFenceProperties,
-      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>
-    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalFenceProperties getExternalFencePropertiesKHR(
-      const PhysicalDeviceExternalFenceInfo & externalFenceInfo,
-      Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result getExternalImageFormatPropertiesNV(
-      VULKAN_HPP_NAMESPACE::Format                            format,
-      VULKAN_HPP_NAMESPACE::ImageType                         type,
-      VULKAN_HPP_NAMESPACE::ImageTiling                       tiling,
-      VULKAN_HPP_NAMESPACE::ImageUsageFlags                   usage,
-      VULKAN_HPP_NAMESPACE::ImageCreateFlags                  flags,
-      VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV   externalHandleType,
-      VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV * pExternalImageFormatProperties,
-      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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
-      typename ResultValueType<VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV>::type
-      getExternalImageFormatPropertiesNV(
-        VULKAN_HPP_NAMESPACE::Format                                             format,
-        VULKAN_HPP_NAMESPACE::ImageType                                          type,
-        VULKAN_HPP_NAMESPACE::ImageTiling                                        tiling,
-        VULKAN_HPP_NAMESPACE::ImageUsageFlags                                    usage,
-        VULKAN_HPP_NAMESPACE::ImageCreateFlags flags                             VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
-        VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV externalHandleType VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
-        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void getExternalSemaphoreProperties(
-      const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,
-      VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties *               pExternalSemaphoreProperties,
-      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>
-    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties getExternalSemaphoreProperties(
-      const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo,
-      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 getExternalSemaphorePropertiesKHR(
-      const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,
-      VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties *               pExternalSemaphoreProperties,
-      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>
-    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties getExternalSemaphorePropertiesKHR(
-      const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo,
-      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 getFeatures( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures * pFeatures,
-                      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>
-    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures
-      getFeatures( 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 getFeatures2( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 * pFeatures,
-                       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>
-    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2
-      getFeatures2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
-      getFeatures2( 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 getFeatures2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 * pFeatures,
-                          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>
-    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2
-      getFeatures2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
-      getFeatures2KHR( 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 getFormatProperties( VULKAN_HPP_NAMESPACE::Format             format,
-                              VULKAN_HPP_NAMESPACE::FormatProperties * pFormatProperties,
-                              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>
-    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties
-                         getFormatProperties( VULKAN_HPP_NAMESPACE::Format format,
-                                              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 getFormatProperties2( VULKAN_HPP_NAMESPACE::Format              format,
-                               VULKAN_HPP_NAMESPACE::FormatProperties2 * pFormatProperties,
-                               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>
-    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties2
-                         getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format,
-                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
-                         getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format,
-                                               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
-      getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format              format,
-                               VULKAN_HPP_NAMESPACE::FormatProperties2 * pFormatProperties,
-                               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>
-    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties2
-                         getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format,
-                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
-                         getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format,
-                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+    //=== VK_KHR_fragment_shading_rate ===
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD Result getFragmentShadingRatesKHR(
@@ -68238,351 +68922,55 @@ namespace VULKAN_HPP_NAMESPACE
         Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      getImageFormatProperties( VULKAN_HPP_NAMESPACE::Format                  format,
-                                VULKAN_HPP_NAMESPACE::ImageType               type,
-                                VULKAN_HPP_NAMESPACE::ImageTiling             tiling,
-                                VULKAN_HPP_NAMESPACE::ImageUsageFlags         usage,
-                                VULKAN_HPP_NAMESPACE::ImageCreateFlags        flags,
-                                VULKAN_HPP_NAMESPACE::ImageFormatProperties * pImageFormatProperties,
-                                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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageFormatProperties>::type
-      getImageFormatProperties( VULKAN_HPP_NAMESPACE::Format                 format,
-                                VULKAN_HPP_NAMESPACE::ImageType              type,
-                                VULKAN_HPP_NAMESPACE::ImageTiling            tiling,
-                                VULKAN_HPP_NAMESPACE::ImageUsageFlags        usage,
-                                VULKAN_HPP_NAMESPACE::ImageCreateFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
-                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result getImageFormatProperties2(
-      const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 * pImageFormatInfo,
-      VULKAN_HPP_NAMESPACE::ImageFormatProperties2 *               pImageFormatProperties,
-      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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>::type
-      getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo,
-                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<StructureChain<X, Y, Z...>>::type
-      getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo,
-                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result getImageFormatProperties2KHR(
-      const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 * pImageFormatInfo,
-      VULKAN_HPP_NAMESPACE::ImageFormatProperties2 *               pImageFormatProperties,
-      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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>::type
-      getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo,
-                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<StructureChain<X, Y, Z...>>::type
-      getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo,
-                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void getMemoryProperties( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties * pMemoryProperties,
-                              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>
-    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties
-      getMemoryProperties( 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 getMemoryProperties2( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 * pMemoryProperties,
-                               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>
-    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2
-      getMemoryProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
-      getMemoryProperties2( 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
-      getMemoryProperties2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 * pMemoryProperties,
-                               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>
-    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2
-      getMemoryProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
-      getMemoryProperties2KHR( 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 getMultisamplePropertiesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits        samples,
-                                      VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT * pMultisampleProperties,
-                                      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>
-    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT getMultisamplePropertiesEXT(
-      VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,
-      Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+    //=== VK_EXT_tooling_info ===
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD Result
-      getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
-                               uint32_t *                       pRectCount,
-                               VULKAN_HPP_NAMESPACE::Rect2D *   pRects,
-                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Rect2DAllocator = std::allocator<Rect2D>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<Rect2D, Rect2DAllocator>>::type
-      getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
-                               Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename Rect2DAllocator = std::allocator<Rect2D>,
-              typename Dispatch        = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B               = Rect2DAllocator,
-              typename std::enable_if<std::is_same<typename B::value_type, Rect2D>::value, int>::type = 0>
-    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<Rect2D, Rect2DAllocator>>::type
-      getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
-                               Rect2DAllocator &                rect2DAllocator,
-                               Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void getProperties( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties * pProperties,
-                        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>
-    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties
-      getProperties( 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 getProperties2( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 * pProperties,
-                         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>
-    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2
-      getProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
-      getProperties2( 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 getProperties2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 * pProperties,
+      getToolPropertiesEXT( uint32_t *                                              pToolCount,
+                            VULKAN_HPP_NAMESPACE::PhysicalDeviceToolPropertiesEXT * pToolProperties,
                             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>
-    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2
-      getProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
-      getProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+    template <typename PhysicalDeviceToolPropertiesEXTAllocator = std::allocator<PhysicalDeviceToolPropertiesEXT>,
+              typename Dispatch                                 = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD typename ResultValueType<
+      std::vector<PhysicalDeviceToolPropertiesEXT, PhysicalDeviceToolPropertiesEXTAllocator>>::type
+      getToolPropertiesEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <typename PhysicalDeviceToolPropertiesEXTAllocator = std::allocator<PhysicalDeviceToolPropertiesEXT>,
+              typename Dispatch                                 = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B                                        = PhysicalDeviceToolPropertiesEXTAllocator,
+              typename std::enable_if<std::is_same<typename B::value_type, PhysicalDeviceToolPropertiesEXT>::value,
+                                      int>::type                = 0>
+    VULKAN_HPP_NODISCARD typename ResultValueType<
+      std::vector<PhysicalDeviceToolPropertiesEXT, PhysicalDeviceToolPropertiesEXTAllocator>>::type
+      getToolPropertiesEXT( PhysicalDeviceToolPropertiesEXTAllocator & physicalDeviceToolPropertiesEXTAllocator,
+                            Dispatch const & d                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+    //=== VK_NV_cooperative_matrix ===
+
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void getQueueFamilyPerformanceQueryPassesKHR(
-      const VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR * pPerformanceQueryCreateInfo,
-      uint32_t *                                                      pNumPasses,
+    VULKAN_HPP_NODISCARD Result getCooperativeMatrixPropertiesNV(
+      uint32_t *                                            pPropertyCount,
+      VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV * pProperties,
       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>
-    VULKAN_HPP_NODISCARD uint32_t getQueueFamilyPerformanceQueryPassesKHR(
-      const QueryPoolPerformanceCreateInfoKHR & performanceQueryCreateInfo,
-      Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+    template <typename CooperativeMatrixPropertiesNVAllocator = std::allocator<CooperativeMatrixPropertiesNV>,
+              typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD
+      typename ResultValueType<std::vector<CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator>>::type
+      getCooperativeMatrixPropertiesNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <typename CooperativeMatrixPropertiesNVAllocator = std::allocator<CooperativeMatrixPropertiesNV>,
+              typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B                                      = CooperativeMatrixPropertiesNVAllocator,
+              typename std::enable_if<std::is_same<typename B::value_type, CooperativeMatrixPropertiesNV>::value,
+                                      int>::type              = 0>
+    VULKAN_HPP_NODISCARD
+      typename ResultValueType<std::vector<CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator>>::type
+      getCooperativeMatrixPropertiesNV( CooperativeMatrixPropertiesNVAllocator & cooperativeMatrixPropertiesNVAllocator,
+                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void
-      getQueueFamilyProperties( uint32_t *                                    pQueueFamilyPropertyCount,
-                                VULKAN_HPP_NAMESPACE::QueueFamilyProperties * pQueueFamilyProperties,
-                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename QueueFamilyPropertiesAllocator = std::allocator<QueueFamilyProperties>,
-              typename Dispatch                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD std::vector<QueueFamilyProperties, QueueFamilyPropertiesAllocator>
-                         getQueueFamilyProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <
-      typename QueueFamilyPropertiesAllocator = std::allocator<QueueFamilyProperties>,
-      typename Dispatch                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-      typename B                              = QueueFamilyPropertiesAllocator,
-      typename std::enable_if<std::is_same<typename B::value_type, QueueFamilyProperties>::value, int>::type = 0>
-    VULKAN_HPP_NODISCARD std::vector<QueueFamilyProperties, QueueFamilyPropertiesAllocator>
-                         getQueueFamilyProperties( QueueFamilyPropertiesAllocator & queueFamilyPropertiesAllocator,
-                                                   Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void getQueueFamilyProperties2( uint32_t *                                     pQueueFamilyPropertyCount,
-                                    VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 * pQueueFamilyProperties,
-                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
-      VULKAN_HPP_NOEXCEPT;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename QueueFamilyProperties2Allocator = std::allocator<QueueFamilyProperties2>,
-              typename Dispatch                        = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator>
-                         getQueueFamilyProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <
-      typename QueueFamilyProperties2Allocator = std::allocator<QueueFamilyProperties2>,
-      typename Dispatch                        = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-      typename B                               = QueueFamilyProperties2Allocator,
-      typename std::enable_if<std::is_same<typename B::value_type, QueueFamilyProperties2>::value, int>::type = 0>
-    VULKAN_HPP_NODISCARD std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator>
-                         getQueueFamilyProperties2( QueueFamilyProperties2Allocator & queueFamilyProperties2Allocator,
-                                                    Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename StructureChain,
-              typename StructureChainAllocator = std::allocator<StructureChain>,
-              typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>
-                         getQueueFamilyProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename StructureChain,
-              typename StructureChainAllocator = std::allocator<StructureChain>,
-              typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B                       = StructureChainAllocator,
-              typename std::enable_if<std::is_same<typename B::value_type, StructureChain>::value, int>::type = 0>
-    VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>
-                         getQueueFamilyProperties2( StructureChainAllocator & structureChainAllocator,
-                                                    Dispatch const & d        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void getQueueFamilyProperties2KHR( uint32_t *                                     pQueueFamilyPropertyCount,
-                                       VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 * pQueueFamilyProperties,
-                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
-      VULKAN_HPP_NOEXCEPT;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename QueueFamilyProperties2Allocator = std::allocator<QueueFamilyProperties2>,
-              typename Dispatch                        = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator>
-      getQueueFamilyProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <
-      typename QueueFamilyProperties2Allocator = std::allocator<QueueFamilyProperties2>,
-      typename Dispatch                        = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-      typename B                               = QueueFamilyProperties2Allocator,
-      typename std::enable_if<std::is_same<typename B::value_type, QueueFamilyProperties2>::value, int>::type = 0>
-    VULKAN_HPP_NODISCARD std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator>
-      getQueueFamilyProperties2KHR( QueueFamilyProperties2Allocator & queueFamilyProperties2Allocator,
-                                    Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename StructureChain,
-              typename StructureChainAllocator = std::allocator<StructureChain>,
-              typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>
-      getQueueFamilyProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename StructureChain,
-              typename StructureChainAllocator = std::allocator<StructureChain>,
-              typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B                       = StructureChainAllocator,
-              typename std::enable_if<std::is_same<typename B::value_type, StructureChain>::value, int>::type = 0>
-    VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>
-                         getQueueFamilyProperties2KHR( StructureChainAllocator & structureChainAllocator,
-                                                       Dispatch const & d        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#if defined( VK_USE_PLATFORM_SCREEN_QNX )
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    Bool32 getScreenPresentationSupportQNX( uint32_t                queueFamilyIndex,
-                                            struct _screen_window * window,
-                                            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>
-    Bool32 getScreenPresentationSupportQNX( uint32_t                queueFamilyIndex,
-                                            struct _screen_window & window,
-                                            Dispatch const & d      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
-      VULKAN_HPP_NOEXCEPT;
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_USE_PLATFORM_SCREEN_QNX*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format                        format,
-                                         VULKAN_HPP_NAMESPACE::ImageType                     type,
-                                         VULKAN_HPP_NAMESPACE::SampleCountFlagBits           samples,
-                                         VULKAN_HPP_NAMESPACE::ImageUsageFlags               usage,
-                                         VULKAN_HPP_NAMESPACE::ImageTiling                   tiling,
-                                         uint32_t *                                          pPropertyCount,
-                                         VULKAN_HPP_NAMESPACE::SparseImageFormatProperties * pProperties,
-                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
-      VULKAN_HPP_NOEXCEPT;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename SparseImageFormatPropertiesAllocator = std::allocator<SparseImageFormatProperties>,
-              typename Dispatch                             = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD std::vector<SparseImageFormatProperties, SparseImageFormatPropertiesAllocator>
-                         getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format              format,
-                                                         VULKAN_HPP_NAMESPACE::ImageType           type,
-                                                         VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,
-                                                         VULKAN_HPP_NAMESPACE::ImageUsageFlags     usage,
-                                                         VULKAN_HPP_NAMESPACE::ImageTiling         tiling,
-                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <
-      typename SparseImageFormatPropertiesAllocator = std::allocator<SparseImageFormatProperties>,
-      typename Dispatch                             = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-      typename B                                    = SparseImageFormatPropertiesAllocator,
-      typename std::enable_if<std::is_same<typename B::value_type, SparseImageFormatProperties>::value, int>::type = 0>
-    VULKAN_HPP_NODISCARD std::vector<SparseImageFormatProperties, SparseImageFormatPropertiesAllocator>
-                         getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format              format,
-                                                         VULKAN_HPP_NAMESPACE::ImageType           type,
-                                                         VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,
-                                                         VULKAN_HPP_NAMESPACE::ImageUsageFlags     usage,
-                                                         VULKAN_HPP_NAMESPACE::ImageTiling         tiling,
-                                                         SparseImageFormatPropertiesAllocator &    sparseImageFormatPropertiesAllocator,
-                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void getSparseImageFormatProperties2(
-      const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,
-      uint32_t *                                                         pPropertyCount,
-      VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 *               pProperties,
-      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename SparseImageFormatProperties2Allocator = std::allocator<SparseImageFormatProperties2>,
-              typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
-                         getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
-                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <
-      typename SparseImageFormatProperties2Allocator = std::allocator<SparseImageFormatProperties2>,
-      typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-      typename B                                     = SparseImageFormatProperties2Allocator,
-      typename std::enable_if<std::is_same<typename B::value_type, SparseImageFormatProperties2>::value, int>::type = 0>
-    VULKAN_HPP_NODISCARD std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
-                         getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
-                                                          SparseImageFormatProperties2Allocator & sparseImageFormatProperties2Allocator,
-                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void getSparseImageFormatProperties2KHR(
-      const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,
-      uint32_t *                                                         pPropertyCount,
-      VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 *               pProperties,
-      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename SparseImageFormatProperties2Allocator = std::allocator<SparseImageFormatProperties2>,
-              typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
-                         getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
-                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <
-      typename SparseImageFormatProperties2Allocator = std::allocator<SparseImageFormatProperties2>,
-      typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-      typename B                                     = SparseImageFormatProperties2Allocator,
-      typename std::enable_if<std::is_same<typename B::value_type, SparseImageFormatProperties2>::value, int>::type = 0>
-    VULKAN_HPP_NODISCARD std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
-                         getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
-                                                             SparseImageFormatProperties2Allocator & sparseImageFormatProperties2Allocator,
-                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+    //=== VK_NV_coverage_reduction_mode ===
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD Result getSupportedFramebufferMixedSamplesCombinationsNV(
@@ -68610,93 +68998,9 @@ namespace VULKAN_HPP_NAMESPACE
         Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result getSurfaceCapabilities2EXT(
-      VULKAN_HPP_NAMESPACE::SurfaceKHR                surface,
-      VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT * pSurfaceCapabilities,
-      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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
-      typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT>::type
-      getSurfaceCapabilities2EXT( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
-                                  Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result getSurfaceCapabilities2KHR(
-      const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
-      VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR *             pSurfaceCapabilities,
-      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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
-      typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR>::type
-      getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
-                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<StructureChain<X, Y, Z...>>::type
-      getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
-                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result getSurfaceCapabilitiesKHR(
-      VULKAN_HPP_NAMESPACE::SurfaceKHR               surface,
-      VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR * pSurfaceCapabilities,
-      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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR>::type
-      getSurfaceCapabilitiesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
-                                 Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
-                             uint32_t *                                                  pSurfaceFormatCount,
-                             VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR *                   pSurfaceFormats,
-                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename SurfaceFormat2KHRAllocator = std::allocator<SurfaceFormat2KHR>,
-              typename Dispatch                   = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<SurfaceFormat2KHR, SurfaceFormat2KHRAllocator>>::type
-      getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
-                             Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename SurfaceFormat2KHRAllocator = std::allocator<SurfaceFormat2KHR>,
-              typename Dispatch                   = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B                          = SurfaceFormat2KHRAllocator,
-              typename std::enable_if<std::is_same<typename B::value_type, SurfaceFormat2KHR>::value, int>::type = 0>
-    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<SurfaceFormat2KHR, SurfaceFormat2KHRAllocator>>::type
-      getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
-                             SurfaceFormat2KHRAllocator &          surfaceFormat2KHRAllocator,
-                             Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR         surface,
-                            uint32_t *                               pSurfaceFormatCount,
-                            VULKAN_HPP_NAMESPACE::SurfaceFormatKHR * pSurfaceFormats,
-                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename SurfaceFormatKHRAllocator = std::allocator<SurfaceFormatKHR>,
-              typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<SurfaceFormatKHR, SurfaceFormatKHRAllocator>>::type
-      getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
-                            Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename SurfaceFormatKHRAllocator = std::allocator<SurfaceFormatKHR>,
-              typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B                         = SurfaceFormatKHRAllocator,
-              typename std::enable_if<std::is_same<typename B::value_type, SurfaceFormatKHR>::value, int>::type = 0>
-    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<SurfaceFormatKHR, SurfaceFormatKHRAllocator>>::type
-      getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
-                            SurfaceFormatKHRAllocator &      surfaceFormatKHRAllocator,
-                            Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
 #if defined( VK_USE_PLATFORM_WIN32_KHR )
+    //=== VK_EXT_full_screen_exclusive ===
+
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD Result getSurfacePresentModes2EXT(
       const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
@@ -68720,187 +69024,21 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VK_USE_PLATFORM_WIN32_KHR*/
 
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result getSurfacePresentModesKHR(
-      VULKAN_HPP_NAMESPACE::SurfaceKHR       surface,
-      uint32_t *                             pPresentModeCount,
-      VULKAN_HPP_NAMESPACE::PresentModeKHR * pPresentModes,
-      Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename PresentModeKHRAllocator = std::allocator<PresentModeKHR>,
-              typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PresentModeKHR, PresentModeKHRAllocator>>::type
-      getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
-                                 Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename PresentModeKHRAllocator = std::allocator<PresentModeKHR>,
-              typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B                       = PresentModeKHRAllocator,
-              typename std::enable_if<std::is_same<typename B::value_type, PresentModeKHR>::value, int>::type = 0>
-    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PresentModeKHR, PresentModeKHRAllocator>>::type
-      getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
-                                 PresentModeKHRAllocator &        presentModeKHRAllocator,
-                                 Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      getSurfaceSupportKHR( uint32_t                         queueFamilyIndex,
-                            VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
-                            VULKAN_HPP_NAMESPACE::Bool32 *   pSupported,
-                            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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::Bool32>::type
-      getSurfaceSupportKHR( uint32_t                         queueFamilyIndex,
-                            VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
-                            Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      getToolPropertiesEXT( uint32_t *                                              pToolCount,
-                            VULKAN_HPP_NAMESPACE::PhysicalDeviceToolPropertiesEXT * pToolProperties,
-                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename PhysicalDeviceToolPropertiesEXTAllocator = std::allocator<PhysicalDeviceToolPropertiesEXT>,
-              typename Dispatch                                 = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD typename ResultValueType<
-      std::vector<PhysicalDeviceToolPropertiesEXT, PhysicalDeviceToolPropertiesEXTAllocator>>::type
-      getToolPropertiesEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename PhysicalDeviceToolPropertiesEXTAllocator = std::allocator<PhysicalDeviceToolPropertiesEXT>,
-              typename Dispatch                                 = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B                                        = PhysicalDeviceToolPropertiesEXTAllocator,
-              typename std::enable_if<std::is_same<typename B::value_type, PhysicalDeviceToolPropertiesEXT>::value,
-                                      int>::type                = 0>
-    VULKAN_HPP_NODISCARD typename ResultValueType<
-      std::vector<PhysicalDeviceToolPropertiesEXT, PhysicalDeviceToolPropertiesEXTAllocator>>::type
-      getToolPropertiesEXT( PhysicalDeviceToolPropertiesEXTAllocator & physicalDeviceToolPropertiesEXTAllocator,
-                            Dispatch const & d                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#if defined( VK_ENABLE_BETA_EXTENSIONS )
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileKHR * pVideoProfile,
-                               VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR *  pCapabilities,
-                               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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR>::type
-      getVideoCapabilitiesKHR( const VideoProfileKHR & videoProfile,
-                               Dispatch const & d      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<StructureChain<X, Y, Z...>>::type
-      getVideoCapabilitiesKHR( const VideoProfileKHR & videoProfile,
-                               Dispatch const & d      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_ENABLE_BETA_EXTENSIONS*/
-
-#if defined( VK_ENABLE_BETA_EXTENSIONS )
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result getVideoFormatPropertiesKHR(
-      const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR * pVideoFormatInfo,
-      uint32_t *                                                     pVideoFormatPropertyCount,
-      VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR *               pVideoFormatProperties,
-      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename VideoFormatPropertiesKHRAllocator = std::allocator<VideoFormatPropertiesKHR>,
-              typename Dispatch                          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD
-      typename ResultValueType<std::vector<VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator>>::type
-      getVideoFormatPropertiesKHR( const PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo,
-                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <
-      typename VideoFormatPropertiesKHRAllocator = std::allocator<VideoFormatPropertiesKHR>,
-      typename Dispatch                          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-      typename B                                 = VideoFormatPropertiesKHRAllocator,
-      typename std::enable_if<std::is_same<typename B::value_type, VideoFormatPropertiesKHR>::value, int>::type = 0>
-    VULKAN_HPP_NODISCARD
-      typename ResultValueType<std::vector<VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator>>::type
-      getVideoFormatPropertiesKHR( const PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo,
-                                   VideoFormatPropertiesKHRAllocator &      videoFormatPropertiesKHRAllocator,
-                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_ENABLE_BETA_EXTENSIONS*/
-
-#if defined( VK_USE_PLATFORM_WAYLAND_KHR )
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    Bool32 getWaylandPresentationSupportKHR( uint32_t            queueFamilyIndex,
-                                             struct wl_display * display,
-                                             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>
-    Bool32 getWaylandPresentationSupportKHR( uint32_t            queueFamilyIndex,
-                                             struct wl_display & display,
-                                             Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
-      VULKAN_HPP_NOEXCEPT;
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_USE_PLATFORM_WAYLAND_KHR*/
-
 #if defined( VK_USE_PLATFORM_WIN32_KHR )
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    Bool32 getWin32PresentationSupportKHR( uint32_t           queueFamilyIndex,
-                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
-      VULKAN_HPP_NOEXCEPT;
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+    //=== VK_NV_acquire_winrt_display ===
 
-#if defined( VK_USE_PLATFORM_XCB_KHR )
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    Bool32 getXcbPresentationSupportKHR( uint32_t           queueFamilyIndex,
-                                         xcb_connection_t * connection,
-                                         xcb_visualid_t     visual_id,
-                                         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>
-    Bool32 getXcbPresentationSupportKHR( uint32_t           queueFamilyIndex,
-                                         xcb_connection_t & connection,
-                                         xcb_visualid_t     visual_id,
-                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
-      VULKAN_HPP_NOEXCEPT;
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_USE_PLATFORM_XCB_KHR*/
-
-#if defined( VK_USE_PLATFORM_XLIB_KHR )
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    Bool32 getXlibPresentationSupportKHR( uint32_t           queueFamilyIndex,
-                                          Display *          dpy,
-                                          VisualID           visualID,
-                                          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>
-    Bool32 getXlibPresentationSupportKHR( uint32_t           queueFamilyIndex,
-                                          Display &          dpy,
-                                          VisualID           visualID,
-                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
-      VULKAN_HPP_NOEXCEPT;
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_USE_PLATFORM_XLIB_KHR*/
-
-#if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
+#  ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD Result
-      getRandROutputDisplayEXT( Display *                          dpy,
-                                RROutput                           rrOutput,
-                                VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplay,
-                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+      acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display,
+                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#  else
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type getRandROutputDisplayEXT(
-      Display & dpy, RROutput rrOutput, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#    ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type
-      getRandROutputDisplayEXTUnique( Display &          dpy,
-                                      RROutput           rrOutput,
-                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif     /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
+         acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display,
+                                Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
-#if defined( VK_USE_PLATFORM_WIN32_KHR )
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD Result
       getWinrtDisplayNV( uint32_t                           deviceRelativeId,
@@ -68920,16 +69058,39 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif     /*VK_USE_PLATFORM_WIN32_KHR*/
 
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+#if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
+    //=== VK_EXT_directfb_surface ===
+
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    Result releaseDisplayEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display,
-                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#else
+    Bool32 getDirectFBPresentationSupportEXT( uint32_t           queueFamilyIndex,
+                                              IDirectFB *        dfb,
+                                              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>
-    typename ResultValueType<void>::type
-         releaseDisplayEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display,
-                            Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+    Bool32 getDirectFBPresentationSupportEXT( uint32_t           queueFamilyIndex,
+                                              IDirectFB &        dfb,
+                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
+      VULKAN_HPP_NOEXCEPT;
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VK_USE_PLATFORM_DIRECTFB_EXT*/
+
+#if defined( VK_USE_PLATFORM_SCREEN_QNX )
+    //=== VK_QNX_screen_surface ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    Bool32 getScreenPresentationSupportQNX( uint32_t                queueFamilyIndex,
+                                            struct _screen_window * window,
+                                            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>
+    Bool32 getScreenPresentationSupportQNX( uint32_t                queueFamilyIndex,
+                                            struct _screen_window & window,
+                                            Dispatch const & d      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
+      VULKAN_HPP_NOEXCEPT;
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VK_USE_PLATFORM_SCREEN_QNX*/
 
     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPhysicalDevice() const VULKAN_HPP_NOEXCEPT
     {
@@ -101021,503 +101182,7 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
-#if defined( VK_USE_PLATFORM_ANDROID_KHR )
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      createAndroidSurfaceKHR( const VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR * pCreateInfo,
-                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks *         pAllocator,
-                               VULKAN_HPP_NAMESPACE::SurfaceKHR *                        pSurface,
-                               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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
-      createAndroidSurfaceKHR( const AndroidSurfaceCreateInfoKHR & createInfo,
-                               Optional<const AllocationCallbacks> allocator
-                                                  VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#    ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
-      createAndroidSurfaceKHRUnique( const AndroidSurfaceCreateInfoKHR & createInfo,
-                                     Optional<const AllocationCallbacks> allocator
-                                                        VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif     /*VK_USE_PLATFORM_ANDROID_KHR*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result createDebugReportCallbackEXT(
-      const VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT * pCreateInfo,
-      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *              pAllocator,
-      VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT *                 pCallback,
-      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>
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT>::type createDebugReportCallbackEXT(
-      const DebugReportCallbackCreateInfoEXT &      createInfo,
-      Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-      Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_INLINE
-      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT, Dispatch>>::type
-      createDebugReportCallbackEXTUnique( const DebugReportCallbackCreateInfoEXT & createInfo,
-                                          Optional<const AllocationCallbacks> allocator
-                                                             VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result createDebugUtilsMessengerEXT(
-      const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT * pCreateInfo,
-      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *              pAllocator,
-      VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT *                 pMessenger,
-      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>
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT>::type createDebugUtilsMessengerEXT(
-      const DebugUtilsMessengerCreateInfoEXT &      createInfo,
-      Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-      Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_INLINE
-      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT, Dispatch>>::type
-      createDebugUtilsMessengerEXTUnique( const DebugUtilsMessengerCreateInfoEXT & createInfo,
-                                          Optional<const AllocationCallbacks> allocator
-                                                             VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      createDirectFBSurfaceEXT( const VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT * pCreateInfo,
-                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks *          pAllocator,
-                                VULKAN_HPP_NAMESPACE::SurfaceKHR *                         pSurface,
-                                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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
-      createDirectFBSurfaceEXT( const DirectFBSurfaceCreateInfoEXT & createInfo,
-                                Optional<const AllocationCallbacks> allocator
-                                                   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#    ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
-      createDirectFBSurfaceEXTUnique( const DirectFBSurfaceCreateInfoEXT & createInfo,
-                                      Optional<const AllocationCallbacks> allocator
-                                                         VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif     /*VK_USE_PLATFORM_DIRECTFB_EXT*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result createDisplayPlaneSurfaceKHR(
-      const VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR * pCreateInfo,
-      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *         pAllocator,
-      VULKAN_HPP_NAMESPACE::SurfaceKHR *                        pSurface,
-      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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
-      createDisplayPlaneSurfaceKHR( const DisplaySurfaceCreateInfoKHR & createInfo,
-                                    Optional<const AllocationCallbacks> allocator
-                                                       VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
-      createDisplayPlaneSurfaceKHRUnique( const DisplaySurfaceCreateInfoKHR & createInfo,
-                                          Optional<const AllocationCallbacks> allocator
-                                                             VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      createHeadlessSurfaceEXT( const VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT * pCreateInfo,
-                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks *          pAllocator,
-                                VULKAN_HPP_NAMESPACE::SurfaceKHR *                         pSurface,
-                                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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
-      createHeadlessSurfaceEXT( const HeadlessSurfaceCreateInfoEXT & createInfo,
-                                Optional<const AllocationCallbacks> allocator
-                                                   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
-      createHeadlessSurfaceEXTUnique( const HeadlessSurfaceCreateInfoEXT & createInfo,
-                                      Optional<const AllocationCallbacks> allocator
-                                                         VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#if defined( VK_USE_PLATFORM_IOS_MVK )
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      createIOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK * pCreateInfo,
-                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks *     pAllocator,
-                           VULKAN_HPP_NAMESPACE::SurfaceKHR *                    pSurface,
-                           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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
-      createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK &               createInfo,
-                           Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#    ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
-      createIOSSurfaceMVKUnique( const IOSSurfaceCreateInfoMVK & createInfo,
-                                 Optional<const AllocationCallbacks> allocator
-                                                    VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif     /*VK_USE_PLATFORM_IOS_MVK*/
-
-#if defined( VK_USE_PLATFORM_FUCHSIA )
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result createImagePipeSurfaceFUCHSIA(
-      const VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA * pCreateInfo,
-      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *               pAllocator,
-      VULKAN_HPP_NAMESPACE::SurfaceKHR *                              pSurface,
-      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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
-      createImagePipeSurfaceFUCHSIA( const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo,
-                                     Optional<const AllocationCallbacks> allocator
-                                                        VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#    ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
-      createImagePipeSurfaceFUCHSIAUnique( const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo,
-                                           Optional<const AllocationCallbacks> allocator
-                                                              VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif     /*VK_USE_PLATFORM_FUCHSIA*/
-
-#if defined( VK_USE_PLATFORM_MACOS_MVK )
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      createMacOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK * pCreateInfo,
-                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,
-                             VULKAN_HPP_NAMESPACE::SurfaceKHR *                      pSurface,
-                             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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
-      createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK & createInfo,
-                             Optional<const AllocationCallbacks> allocator
-                                                VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#    ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
-      createMacOSSurfaceMVKUnique( const MacOSSurfaceCreateInfoMVK & createInfo,
-                                   Optional<const AllocationCallbacks> allocator
-                                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif     /*VK_USE_PLATFORM_MACOS_MVK*/
-
-#if defined( VK_USE_PLATFORM_METAL_EXT )
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      createMetalSurfaceEXT( const VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT * pCreateInfo,
-                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,
-                             VULKAN_HPP_NAMESPACE::SurfaceKHR *                      pSurface,
-                             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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
-      createMetalSurfaceEXT( const MetalSurfaceCreateInfoEXT & createInfo,
-                             Optional<const AllocationCallbacks> allocator
-                                                VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#    ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
-      createMetalSurfaceEXTUnique( const MetalSurfaceCreateInfoEXT & createInfo,
-                                   Optional<const AllocationCallbacks> allocator
-                                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif     /*VK_USE_PLATFORM_METAL_EXT*/
-
-#if defined( VK_USE_PLATFORM_SCREEN_QNX )
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      createScreenSurfaceQNX( const VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX * pCreateInfo,
-                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks *        pAllocator,
-                              VULKAN_HPP_NAMESPACE::SurfaceKHR *                       pSurface,
-                              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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
-      createScreenSurfaceQNX( const ScreenSurfaceCreateInfoQNX & createInfo,
-                              Optional<const AllocationCallbacks> allocator
-                                                 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#    ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
-      createScreenSurfaceQNXUnique( const ScreenSurfaceCreateInfoQNX & createInfo,
-                                    Optional<const AllocationCallbacks> allocator
-                                                       VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif     /*VK_USE_PLATFORM_SCREEN_QNX*/
-
-#if defined( VK_USE_PLATFORM_GGP )
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result createStreamDescriptorSurfaceGGP(
-      const VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP * pCreateInfo,
-      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                  pAllocator,
-      VULKAN_HPP_NAMESPACE::SurfaceKHR *                                 pSurface,
-      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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
-      createStreamDescriptorSurfaceGGP( const StreamDescriptorSurfaceCreateInfoGGP & createInfo,
-                                        Optional<const AllocationCallbacks> allocator
-                                                           VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#    ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
-      createStreamDescriptorSurfaceGGPUnique( const StreamDescriptorSurfaceCreateInfoGGP & createInfo,
-                                              Optional<const AllocationCallbacks> allocator
-                                                                 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif     /*VK_USE_PLATFORM_GGP*/
-
-#if defined( VK_USE_PLATFORM_VI_NN )
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      createViSurfaceNN( const VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN * pCreateInfo,
-                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
-                         VULKAN_HPP_NAMESPACE::SurfaceKHR *                  pSurface,
-                         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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
-      createViSurfaceNN( const ViSurfaceCreateInfoNN &                 createInfo,
-                         Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                         Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#    ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
-      createViSurfaceNNUnique( const ViSurfaceCreateInfoNN & createInfo,
-                               Optional<const AllocationCallbacks> allocator
-                                                  VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif     /*VK_USE_PLATFORM_VI_NN*/
-
-#if defined( VK_USE_PLATFORM_WAYLAND_KHR )
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      createWaylandSurfaceKHR( const VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR * pCreateInfo,
-                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks *         pAllocator,
-                               VULKAN_HPP_NAMESPACE::SurfaceKHR *                        pSurface,
-                               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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
-      createWaylandSurfaceKHR( const WaylandSurfaceCreateInfoKHR & createInfo,
-                               Optional<const AllocationCallbacks> allocator
-                                                  VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#    ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
-      createWaylandSurfaceKHRUnique( const WaylandSurfaceCreateInfoKHR & createInfo,
-                                     Optional<const AllocationCallbacks> allocator
-                                                        VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif     /*VK_USE_PLATFORM_WAYLAND_KHR*/
-
-#if defined( VK_USE_PLATFORM_WIN32_KHR )
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      createWin32SurfaceKHR( const VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR * pCreateInfo,
-                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,
-                             VULKAN_HPP_NAMESPACE::SurfaceKHR *                      pSurface,
-                             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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
-      createWin32SurfaceKHR( const Win32SurfaceCreateInfoKHR & createInfo,
-                             Optional<const AllocationCallbacks> allocator
-                                                VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#    ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
-      createWin32SurfaceKHRUnique( const Win32SurfaceCreateInfoKHR & createInfo,
-                                   Optional<const AllocationCallbacks> allocator
-                                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif     /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#if defined( VK_USE_PLATFORM_XCB_KHR )
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      createXcbSurfaceKHR( const VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR * pCreateInfo,
-                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks *     pAllocator,
-                           VULKAN_HPP_NAMESPACE::SurfaceKHR *                    pSurface,
-                           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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
-      createXcbSurfaceKHR( const XcbSurfaceCreateInfoKHR &               createInfo,
-                           Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#    ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
-      createXcbSurfaceKHRUnique( const XcbSurfaceCreateInfoKHR & createInfo,
-                                 Optional<const AllocationCallbacks> allocator
-                                                    VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif     /*VK_USE_PLATFORM_XCB_KHR*/
-
-#if defined( VK_USE_PLATFORM_XLIB_KHR )
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result
-      createXlibSurfaceKHR( const VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR * pCreateInfo,
-                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks *      pAllocator,
-                            VULKAN_HPP_NAMESPACE::SurfaceKHR *                     pSurface,
-                            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>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
-      createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR & createInfo,
-                            Optional<const AllocationCallbacks> allocator
-                                               VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#    ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
-      createXlibSurfaceKHRUnique( const XlibSurfaceCreateInfoKHR & createInfo,
-                                  Optional<const AllocationCallbacks> allocator
-                                                     VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif     /*VK_USE_PLATFORM_XLIB_KHR*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void debugReportMessageEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT      flags,
-                                VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType,
-                                uint64_t                                       object,
-                                size_t                                         location,
-                                int32_t                                        messageCode,
-                                const char *                                   pLayerPrefix,
-                                const char *                                   pMessage,
-                                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 debugReportMessageEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT      flags,
-                                VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType,
-                                uint64_t                                       object,
-                                size_t                                         location,
-                                int32_t                                        messageCode,
-                                const std::string &                            layerPrefix,
-                                const std::string &                            message,
-                                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 destroyDebugReportCallbackEXT( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT      callback,
-                                        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 destroyDebugReportCallbackEXT(
-      VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
-      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( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT      callback,
-                  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::DebugReportCallbackEXT  callback,
-                  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 destroyDebugUtilsMessengerEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT      messenger,
-                                        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 destroyDebugUtilsMessengerEXT(
-      VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
-      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( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT      messenger,
-                  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::DebugUtilsMessengerEXT  messenger,
-                  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*/
+    //=== VK_VERSION_1_0 ===
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     void destroy( const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
@@ -101528,73 +101193,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 destroySurfaceKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR                  surface,
-                            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
-      destroySurfaceKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface      VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
-                         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( VULKAN_HPP_NAMESPACE::SurfaceKHR                  surface,
-                  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::SurfaceKHR              surface,
-                  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>
-    VULKAN_HPP_NODISCARD Result enumeratePhysicalDeviceGroups(
-      uint32_t *                                            pPhysicalDeviceGroupCount,
-      VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties,
-      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<PhysicalDeviceGroupProperties>,
-              typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD
-      typename ResultValueType<std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
-      enumeratePhysicalDeviceGroups( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<PhysicalDeviceGroupProperties>,
-              typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B                                      = PhysicalDeviceGroupPropertiesAllocator,
-              typename std::enable_if<std::is_same<typename B::value_type, PhysicalDeviceGroupProperties>::value,
-                                      int>::type              = 0>
-    VULKAN_HPP_NODISCARD
-      typename ResultValueType<std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
-      enumeratePhysicalDeviceGroups( PhysicalDeviceGroupPropertiesAllocator & physicalDeviceGroupPropertiesAllocator,
-                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result enumeratePhysicalDeviceGroupsKHR(
-      uint32_t *                                            pPhysicalDeviceGroupCount,
-      VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties,
-      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<PhysicalDeviceGroupProperties>,
-              typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD
-      typename ResultValueType<std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
-      enumeratePhysicalDeviceGroupsKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<PhysicalDeviceGroupProperties>,
-              typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B                                      = PhysicalDeviceGroupPropertiesAllocator,
-              typename std::enable_if<std::is_same<typename B::value_type, PhysicalDeviceGroupProperties>::value,
-                                      int>::type              = 0>
-    VULKAN_HPP_NODISCARD
-      typename ResultValueType<std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
-      enumeratePhysicalDeviceGroupsKHR( PhysicalDeviceGroupPropertiesAllocator & physicalDeviceGroupPropertiesAllocator,
-                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD Result
       enumeratePhysicalDevices( uint32_t *                             pPhysicalDeviceCount,
@@ -101625,6 +101223,473 @@ namespace VULKAN_HPP_NAMESPACE
                    Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+    //=== VK_VERSION_1_1 ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result enumeratePhysicalDeviceGroups(
+      uint32_t *                                            pPhysicalDeviceGroupCount,
+      VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties,
+      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<PhysicalDeviceGroupProperties>,
+              typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD
+      typename ResultValueType<std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
+      enumeratePhysicalDeviceGroups( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<PhysicalDeviceGroupProperties>,
+              typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B                                      = PhysicalDeviceGroupPropertiesAllocator,
+              typename std::enable_if<std::is_same<typename B::value_type, PhysicalDeviceGroupProperties>::value,
+                                      int>::type              = 0>
+    VULKAN_HPP_NODISCARD
+      typename ResultValueType<std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
+      enumeratePhysicalDeviceGroups( PhysicalDeviceGroupPropertiesAllocator & physicalDeviceGroupPropertiesAllocator,
+                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    //=== VK_KHR_surface ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void destroySurfaceKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR                  surface,
+                            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
+      destroySurfaceKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface      VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
+                         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( VULKAN_HPP_NAMESPACE::SurfaceKHR                  surface,
+                  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::SurfaceKHR              surface,
+                  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*/
+
+    //=== VK_KHR_display ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result createDisplayPlaneSurfaceKHR(
+      const VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR * pCreateInfo,
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *         pAllocator,
+      VULKAN_HPP_NAMESPACE::SurfaceKHR *                        pSurface,
+      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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
+      createDisplayPlaneSurfaceKHR( const DisplaySurfaceCreateInfoKHR & createInfo,
+                                    Optional<const AllocationCallbacks> allocator
+                                                       VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
+      createDisplayPlaneSurfaceKHRUnique( const DisplaySurfaceCreateInfoKHR & createInfo,
+                                          Optional<const AllocationCallbacks> allocator
+                                                             VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#if defined( VK_USE_PLATFORM_XLIB_KHR )
+    //=== VK_KHR_xlib_surface ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      createXlibSurfaceKHR( const VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR * pCreateInfo,
+                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks *      pAllocator,
+                            VULKAN_HPP_NAMESPACE::SurfaceKHR *                     pSurface,
+                            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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
+      createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR & createInfo,
+                            Optional<const AllocationCallbacks> allocator
+                                               VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#    ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
+      createXlibSurfaceKHRUnique( const XlibSurfaceCreateInfoKHR & createInfo,
+                                  Optional<const AllocationCallbacks> allocator
+                                                     VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif     /*VK_USE_PLATFORM_XLIB_KHR*/
+
+#if defined( VK_USE_PLATFORM_XCB_KHR )
+    //=== VK_KHR_xcb_surface ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      createXcbSurfaceKHR( const VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR * pCreateInfo,
+                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks *     pAllocator,
+                           VULKAN_HPP_NAMESPACE::SurfaceKHR *                    pSurface,
+                           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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
+      createXcbSurfaceKHR( const XcbSurfaceCreateInfoKHR &               createInfo,
+                           Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#    ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
+      createXcbSurfaceKHRUnique( const XcbSurfaceCreateInfoKHR & createInfo,
+                                 Optional<const AllocationCallbacks> allocator
+                                                    VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif     /*VK_USE_PLATFORM_XCB_KHR*/
+
+#if defined( VK_USE_PLATFORM_WAYLAND_KHR )
+    //=== VK_KHR_wayland_surface ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      createWaylandSurfaceKHR( const VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR * pCreateInfo,
+                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks *         pAllocator,
+                               VULKAN_HPP_NAMESPACE::SurfaceKHR *                        pSurface,
+                               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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
+      createWaylandSurfaceKHR( const WaylandSurfaceCreateInfoKHR & createInfo,
+                               Optional<const AllocationCallbacks> allocator
+                                                  VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#    ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
+      createWaylandSurfaceKHRUnique( const WaylandSurfaceCreateInfoKHR & createInfo,
+                                     Optional<const AllocationCallbacks> allocator
+                                                        VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif     /*VK_USE_PLATFORM_WAYLAND_KHR*/
+
+#if defined( VK_USE_PLATFORM_ANDROID_KHR )
+    //=== VK_KHR_android_surface ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      createAndroidSurfaceKHR( const VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR * pCreateInfo,
+                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks *         pAllocator,
+                               VULKAN_HPP_NAMESPACE::SurfaceKHR *                        pSurface,
+                               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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
+      createAndroidSurfaceKHR( const AndroidSurfaceCreateInfoKHR & createInfo,
+                               Optional<const AllocationCallbacks> allocator
+                                                  VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#    ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
+      createAndroidSurfaceKHRUnique( const AndroidSurfaceCreateInfoKHR & createInfo,
+                                     Optional<const AllocationCallbacks> allocator
+                                                        VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif     /*VK_USE_PLATFORM_ANDROID_KHR*/
+
+#if defined( VK_USE_PLATFORM_WIN32_KHR )
+    //=== VK_KHR_win32_surface ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      createWin32SurfaceKHR( const VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR * pCreateInfo,
+                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,
+                             VULKAN_HPP_NAMESPACE::SurfaceKHR *                      pSurface,
+                             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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
+      createWin32SurfaceKHR( const Win32SurfaceCreateInfoKHR & createInfo,
+                             Optional<const AllocationCallbacks> allocator
+                                                VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#    ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
+      createWin32SurfaceKHRUnique( const Win32SurfaceCreateInfoKHR & createInfo,
+                                   Optional<const AllocationCallbacks> allocator
+                                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif     /*VK_USE_PLATFORM_WIN32_KHR*/
+
+    //=== VK_EXT_debug_report ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result createDebugReportCallbackEXT(
+      const VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT * pCreateInfo,
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *              pAllocator,
+      VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT *                 pCallback,
+      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>
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT>::type createDebugReportCallbackEXT(
+      const DebugReportCallbackCreateInfoEXT &      createInfo,
+      Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+      Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT, Dispatch>>::type
+      createDebugReportCallbackEXTUnique( const DebugReportCallbackCreateInfoEXT & createInfo,
+                                          Optional<const AllocationCallbacks> allocator
+                                                             VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void destroyDebugReportCallbackEXT( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT      callback,
+                                        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 destroyDebugReportCallbackEXT(
+      VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
+      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( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT      callback,
+                  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::DebugReportCallbackEXT  callback,
+                  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 debugReportMessageEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT      flags,
+                                VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType,
+                                uint64_t                                       object,
+                                size_t                                         location,
+                                int32_t                                        messageCode,
+                                const char *                                   pLayerPrefix,
+                                const char *                                   pMessage,
+                                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 debugReportMessageEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT      flags,
+                                VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType,
+                                uint64_t                                       object,
+                                size_t                                         location,
+                                int32_t                                        messageCode,
+                                const std::string &                            layerPrefix,
+                                const std::string &                            message,
+                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#if defined( VK_USE_PLATFORM_GGP )
+    //=== VK_GGP_stream_descriptor_surface ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result createStreamDescriptorSurfaceGGP(
+      const VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP * pCreateInfo,
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                  pAllocator,
+      VULKAN_HPP_NAMESPACE::SurfaceKHR *                                 pSurface,
+      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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
+      createStreamDescriptorSurfaceGGP( const StreamDescriptorSurfaceCreateInfoGGP & createInfo,
+                                        Optional<const AllocationCallbacks> allocator
+                                                           VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#    ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
+      createStreamDescriptorSurfaceGGPUnique( const StreamDescriptorSurfaceCreateInfoGGP & createInfo,
+                                              Optional<const AllocationCallbacks> allocator
+                                                                 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif     /*VK_USE_PLATFORM_GGP*/
+
+#if defined( VK_USE_PLATFORM_VI_NN )
+    //=== VK_NN_vi_surface ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      createViSurfaceNN( const VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN * pCreateInfo,
+                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
+                         VULKAN_HPP_NAMESPACE::SurfaceKHR *                  pSurface,
+                         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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
+      createViSurfaceNN( const ViSurfaceCreateInfoNN &                 createInfo,
+                         Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                         Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#    ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
+      createViSurfaceNNUnique( const ViSurfaceCreateInfoNN & createInfo,
+                               Optional<const AllocationCallbacks> allocator
+                                                  VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif     /*VK_USE_PLATFORM_VI_NN*/
+
+    //=== VK_KHR_device_group_creation ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result enumeratePhysicalDeviceGroupsKHR(
+      uint32_t *                                            pPhysicalDeviceGroupCount,
+      VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties,
+      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<PhysicalDeviceGroupProperties>,
+              typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD
+      typename ResultValueType<std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
+      enumeratePhysicalDeviceGroupsKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<PhysicalDeviceGroupProperties>,
+              typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B                                      = PhysicalDeviceGroupPropertiesAllocator,
+              typename std::enable_if<std::is_same<typename B::value_type, PhysicalDeviceGroupProperties>::value,
+                                      int>::type              = 0>
+    VULKAN_HPP_NODISCARD
+      typename ResultValueType<std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
+      enumeratePhysicalDeviceGroupsKHR( PhysicalDeviceGroupPropertiesAllocator & physicalDeviceGroupPropertiesAllocator,
+                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#if defined( VK_USE_PLATFORM_IOS_MVK )
+    //=== VK_MVK_ios_surface ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      createIOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK * pCreateInfo,
+                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks *     pAllocator,
+                           VULKAN_HPP_NAMESPACE::SurfaceKHR *                    pSurface,
+                           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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
+      createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK &               createInfo,
+                           Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#    ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
+      createIOSSurfaceMVKUnique( const IOSSurfaceCreateInfoMVK & createInfo,
+                                 Optional<const AllocationCallbacks> allocator
+                                                    VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif     /*VK_USE_PLATFORM_IOS_MVK*/
+
+#if defined( VK_USE_PLATFORM_MACOS_MVK )
+    //=== VK_MVK_macos_surface ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      createMacOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK * pCreateInfo,
+                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,
+                             VULKAN_HPP_NAMESPACE::SurfaceKHR *                      pSurface,
+                             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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
+      createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK & createInfo,
+                             Optional<const AllocationCallbacks> allocator
+                                                VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#    ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
+      createMacOSSurfaceMVKUnique( const MacOSSurfaceCreateInfoMVK & createInfo,
+                                   Optional<const AllocationCallbacks> allocator
+                                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif     /*VK_USE_PLATFORM_MACOS_MVK*/
+
+    //=== VK_EXT_debug_utils ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result createDebugUtilsMessengerEXT(
+      const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT * pCreateInfo,
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *              pAllocator,
+      VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT *                 pMessenger,
+      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>
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT>::type createDebugUtilsMessengerEXT(
+      const DebugUtilsMessengerCreateInfoEXT &      createInfo,
+      Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+      Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT, Dispatch>>::type
+      createDebugUtilsMessengerEXTUnique( const DebugUtilsMessengerCreateInfoEXT & createInfo,
+                                          Optional<const AllocationCallbacks> allocator
+                                                             VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void destroyDebugUtilsMessengerEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT      messenger,
+                                        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 destroyDebugUtilsMessengerEXT(
+      VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
+      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( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT      messenger,
+                  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::DebugUtilsMessengerEXT  messenger,
+                  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 submitDebugUtilsMessageEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagBitsEXT       messageSeverity,
                                      VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT              messageTypes,
@@ -101640,6 +101705,144 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NOEXCEPT;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+#if defined( VK_USE_PLATFORM_FUCHSIA )
+    //=== VK_FUCHSIA_imagepipe_surface ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result createImagePipeSurfaceFUCHSIA(
+      const VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA * pCreateInfo,
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *               pAllocator,
+      VULKAN_HPP_NAMESPACE::SurfaceKHR *                              pSurface,
+      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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
+      createImagePipeSurfaceFUCHSIA( const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo,
+                                     Optional<const AllocationCallbacks> allocator
+                                                        VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#    ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
+      createImagePipeSurfaceFUCHSIAUnique( const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo,
+                                           Optional<const AllocationCallbacks> allocator
+                                                              VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif     /*VK_USE_PLATFORM_FUCHSIA*/
+
+#if defined( VK_USE_PLATFORM_METAL_EXT )
+    //=== VK_EXT_metal_surface ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      createMetalSurfaceEXT( const VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT * pCreateInfo,
+                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,
+                             VULKAN_HPP_NAMESPACE::SurfaceKHR *                      pSurface,
+                             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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
+      createMetalSurfaceEXT( const MetalSurfaceCreateInfoEXT & createInfo,
+                             Optional<const AllocationCallbacks> allocator
+                                                VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#    ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
+      createMetalSurfaceEXTUnique( const MetalSurfaceCreateInfoEXT & createInfo,
+                                   Optional<const AllocationCallbacks> allocator
+                                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif     /*VK_USE_PLATFORM_METAL_EXT*/
+
+    //=== VK_EXT_headless_surface ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      createHeadlessSurfaceEXT( const VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT * pCreateInfo,
+                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks *          pAllocator,
+                                VULKAN_HPP_NAMESPACE::SurfaceKHR *                         pSurface,
+                                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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
+      createHeadlessSurfaceEXT( const HeadlessSurfaceCreateInfoEXT & createInfo,
+                                Optional<const AllocationCallbacks> allocator
+                                                   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
+      createHeadlessSurfaceEXTUnique( const HeadlessSurfaceCreateInfoEXT & createInfo,
+                                      Optional<const AllocationCallbacks> allocator
+                                                         VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
+    //=== VK_EXT_directfb_surface ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      createDirectFBSurfaceEXT( const VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT * pCreateInfo,
+                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks *          pAllocator,
+                                VULKAN_HPP_NAMESPACE::SurfaceKHR *                         pSurface,
+                                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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
+      createDirectFBSurfaceEXT( const DirectFBSurfaceCreateInfoEXT & createInfo,
+                                Optional<const AllocationCallbacks> allocator
+                                                   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#    ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
+      createDirectFBSurfaceEXTUnique( const DirectFBSurfaceCreateInfoEXT & createInfo,
+                                      Optional<const AllocationCallbacks> allocator
+                                                         VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif     /*VK_USE_PLATFORM_DIRECTFB_EXT*/
+
+#if defined( VK_USE_PLATFORM_SCREEN_QNX )
+    //=== VK_QNX_screen_surface ===
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      createScreenSurfaceQNX( const VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX * pCreateInfo,
+                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks *        pAllocator,
+                              VULKAN_HPP_NAMESPACE::SurfaceKHR *                       pSurface,
+                              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>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
+      createScreenSurfaceQNX( const ScreenSurfaceCreateInfoQNX & createInfo,
+                              Optional<const AllocationCallbacks> allocator
+                                                 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#    ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
+      createScreenSurfaceQNXUnique( const ScreenSurfaceCreateInfoQNX & createInfo,
+                                    Optional<const AllocationCallbacks> allocator
+                                                       VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif     /*VK_USE_PLATFORM_SCREEN_QNX*/
+
     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkInstance() const VULKAN_HPP_NOEXCEPT
     {
       return m_instance;
@@ -101686,6 +101889,8 @@ namespace VULKAN_HPP_NAMESPACE
     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
   };
 
+  //=== VK_VERSION_1_0 ===
+
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch>
   class UniqueHandleTraits<Instance, Dispatch>
@@ -101760,6 +101965,8 @@ namespace VULKAN_HPP_NAMESPACE
                                       Dispatch const & d         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+  //=== VK_VERSION_1_1 ===
+
   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
   VULKAN_HPP_NODISCARD Result enumerateInstanceVersion(
     uint32_t * pApiVersion, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT;
@@ -101769,6 +101976,12 @@ namespace VULKAN_HPP_NAMESPACE
     enumerateInstanceVersion( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+  //===========================
+  //=== COMMAND Definitions ===
+  //===========================
+
+  //=== VK_VERSION_1_0 ===
+
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
     createInstance( const VULKAN_HPP_NAMESPACE::InstanceCreateInfo *  pCreateInfo,
@@ -101819,6 +102032,370 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Instance::destroy( const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                            Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyInstance( m_instance, reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Instance::destroy( Optional<const AllocationCallbacks> allocator,
+                                            Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyInstance( m_instance,
+                         reinterpret_cast<const VkAllocationCallbacks *>(
+                           static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Instance::enumeratePhysicalDevices( uint32_t *                             pPhysicalDeviceCount,
+                                        VULKAN_HPP_NAMESPACE::PhysicalDevice * pPhysicalDevices,
+                                        Dispatch const &                       d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkEnumeratePhysicalDevices(
+      m_instance, pPhysicalDeviceCount, reinterpret_cast<VkPhysicalDevice *>( pPhysicalDevices ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename PhysicalDeviceAllocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
+    typename ResultValueType<std::vector<PhysicalDevice, PhysicalDeviceAllocator>>::type
+    Instance::enumeratePhysicalDevices( Dispatch const & d ) const
+  {
+    std::vector<PhysicalDevice, PhysicalDeviceAllocator> physicalDevices;
+    uint32_t                                             physicalDeviceCount;
+    Result                                               result;
+    do
+    {
+      result = static_cast<Result>( d.vkEnumeratePhysicalDevices( m_instance, &physicalDeviceCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && physicalDeviceCount )
+      {
+        physicalDevices.resize( physicalDeviceCount );
+        result = static_cast<Result>( d.vkEnumeratePhysicalDevices(
+          m_instance, &physicalDeviceCount, reinterpret_cast<VkPhysicalDevice *>( physicalDevices.data() ) ) );
+        VULKAN_HPP_ASSERT( physicalDeviceCount <= physicalDevices.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( physicalDeviceCount < physicalDevices.size() ) )
+    {
+      physicalDevices.resize( physicalDeviceCount );
+    }
+    return createResultValue(
+      result, physicalDevices, VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDevices" );
+  }
+
+  template <typename PhysicalDeviceAllocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, PhysicalDevice>::value, int>::type>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
+    typename ResultValueType<std::vector<PhysicalDevice, PhysicalDeviceAllocator>>::type
+    Instance::enumeratePhysicalDevices( PhysicalDeviceAllocator & physicalDeviceAllocator, Dispatch const & d ) const
+  {
+    std::vector<PhysicalDevice, PhysicalDeviceAllocator> physicalDevices( physicalDeviceAllocator );
+    uint32_t                                             physicalDeviceCount;
+    Result                                               result;
+    do
+    {
+      result = static_cast<Result>( d.vkEnumeratePhysicalDevices( m_instance, &physicalDeviceCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && physicalDeviceCount )
+      {
+        physicalDevices.resize( physicalDeviceCount );
+        result = static_cast<Result>( d.vkEnumeratePhysicalDevices(
+          m_instance, &physicalDeviceCount, reinterpret_cast<VkPhysicalDevice *>( physicalDevices.data() ) ) );
+        VULKAN_HPP_ASSERT( physicalDeviceCount <= physicalDevices.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( physicalDeviceCount < physicalDevices.size() ) )
+    {
+      physicalDevices.resize( physicalDeviceCount );
+    }
+    return createResultValue(
+      result, physicalDevices, VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDevices" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void PhysicalDevice::getFeatures( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures * pFeatures,
+                                                      Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkGetPhysicalDeviceFeatures( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures *>( pFeatures ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures
+                                         PhysicalDevice::getFeatures( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures features;
+    d.vkGetPhysicalDeviceFeatures( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures *>( &features ) );
+    return features;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    PhysicalDevice::getFormatProperties( VULKAN_HPP_NAMESPACE::Format             format,
+                                         VULKAN_HPP_NAMESPACE::FormatProperties * pFormatProperties,
+                                         Dispatch const &                         d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkGetPhysicalDeviceFormatProperties(
+      m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties *>( pFormatProperties ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::FormatProperties
+                                         PhysicalDevice::getFormatProperties( VULKAN_HPP_NAMESPACE::Format format,
+                                         Dispatch const &             d ) const VULKAN_HPP_NOEXCEPT
+  {
+    VULKAN_HPP_NAMESPACE::FormatProperties formatProperties;
+    d.vkGetPhysicalDeviceFormatProperties(
+      m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties *>( &formatProperties ) );
+    return formatProperties;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    PhysicalDevice::getImageFormatProperties( VULKAN_HPP_NAMESPACE::Format                  format,
+                                              VULKAN_HPP_NAMESPACE::ImageType               type,
+                                              VULKAN_HPP_NAMESPACE::ImageTiling             tiling,
+                                              VULKAN_HPP_NAMESPACE::ImageUsageFlags         usage,
+                                              VULKAN_HPP_NAMESPACE::ImageCreateFlags        flags,
+                                              VULKAN_HPP_NAMESPACE::ImageFormatProperties * pImageFormatProperties,
+                                              Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties(
+      m_physicalDevice,
+      static_cast<VkFormat>( format ),
+      static_cast<VkImageType>( type ),
+      static_cast<VkImageTiling>( tiling ),
+      static_cast<VkImageUsageFlags>( usage ),
+      static_cast<VkImageCreateFlags>( flags ),
+      reinterpret_cast<VkImageFormatProperties *>( pImageFormatProperties ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageFormatProperties>::type
+    PhysicalDevice::getImageFormatProperties( VULKAN_HPP_NAMESPACE::Format           format,
+                                              VULKAN_HPP_NAMESPACE::ImageType        type,
+                                              VULKAN_HPP_NAMESPACE::ImageTiling      tiling,
+                                              VULKAN_HPP_NAMESPACE::ImageUsageFlags  usage,
+                                              VULKAN_HPP_NAMESPACE::ImageCreateFlags flags,
+                                              Dispatch const &                       d ) const
+  {
+    VULKAN_HPP_NAMESPACE::ImageFormatProperties imageFormatProperties;
+    Result result = static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties(
+      m_physicalDevice,
+      static_cast<VkFormat>( format ),
+      static_cast<VkImageType>( type ),
+      static_cast<VkImageTiling>( tiling ),
+      static_cast<VkImageUsageFlags>( usage ),
+      static_cast<VkImageCreateFlags>( flags ),
+      reinterpret_cast<VkImageFormatProperties *>( &imageFormatProperties ) ) );
+    return createResultValue(
+      result, imageFormatProperties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void PhysicalDevice::getProperties( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties * pProperties,
+                                                        Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkGetPhysicalDeviceProperties( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties *>( pProperties ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties
+                                         PhysicalDevice::getProperties( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties properties;
+    d.vkGetPhysicalDeviceProperties( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties *>( &properties ) );
+    return properties;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    PhysicalDevice::getQueueFamilyProperties( uint32_t *                                    pQueueFamilyPropertyCount,
+                                              VULKAN_HPP_NAMESPACE::QueueFamilyProperties * pQueueFamilyProperties,
+                                              Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkGetPhysicalDeviceQueueFamilyProperties( m_physicalDevice,
+                                                pQueueFamilyPropertyCount,
+                                                reinterpret_cast<VkQueueFamilyProperties *>( pQueueFamilyProperties ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename QueueFamilyPropertiesAllocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<QueueFamilyProperties, QueueFamilyPropertiesAllocator>
+                                         PhysicalDevice::getQueueFamilyProperties( Dispatch const & d ) const
+  {
+    std::vector<QueueFamilyProperties, QueueFamilyPropertiesAllocator> queueFamilyProperties;
+    uint32_t                                                           queueFamilyPropertyCount;
+    d.vkGetPhysicalDeviceQueueFamilyProperties( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
+    queueFamilyProperties.resize( queueFamilyPropertyCount );
+    d.vkGetPhysicalDeviceQueueFamilyProperties(
+      m_physicalDevice,
+      &queueFamilyPropertyCount,
+      reinterpret_cast<VkQueueFamilyProperties *>( queueFamilyProperties.data() ) );
+    VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() );
+    return queueFamilyProperties;
+  }
+
+  template <typename QueueFamilyPropertiesAllocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, QueueFamilyProperties>::value, int>::type>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<QueueFamilyProperties, QueueFamilyPropertiesAllocator>
+    PhysicalDevice::getQueueFamilyProperties( QueueFamilyPropertiesAllocator & queueFamilyPropertiesAllocator,
+                                              Dispatch const &                 d ) const
+  {
+    std::vector<QueueFamilyProperties, QueueFamilyPropertiesAllocator> queueFamilyProperties(
+      queueFamilyPropertiesAllocator );
+    uint32_t queueFamilyPropertyCount;
+    d.vkGetPhysicalDeviceQueueFamilyProperties( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
+    queueFamilyProperties.resize( queueFamilyPropertyCount );
+    d.vkGetPhysicalDeviceQueueFamilyProperties(
+      m_physicalDevice,
+      &queueFamilyPropertyCount,
+      reinterpret_cast<VkQueueFamilyProperties *>( queueFamilyProperties.data() ) );
+    VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() );
+    return queueFamilyProperties;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    PhysicalDevice::getMemoryProperties( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties * pMemoryProperties,
+                                         Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkGetPhysicalDeviceMemoryProperties( m_physicalDevice,
+                                           reinterpret_cast<VkPhysicalDeviceMemoryProperties *>( pMemoryProperties ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties
+    PhysicalDevice::getMemoryProperties( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties memoryProperties;
+    d.vkGetPhysicalDeviceMemoryProperties( m_physicalDevice,
+                                           reinterpret_cast<VkPhysicalDeviceMemoryProperties *>( &memoryProperties ) );
+    return memoryProperties;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE PFN_vkVoidFunction Instance::getProcAddr( const char *     pName,
+                                                              Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return d.vkGetInstanceProcAddr( m_instance, pName );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE PFN_vkVoidFunction Instance::getProcAddr( const std::string & name,
+                                                              Dispatch const &    d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return d.vkGetInstanceProcAddr( m_instance, name.c_str() );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE PFN_vkVoidFunction Device::getProcAddr( const char *     pName,
+                                                            Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return d.vkGetDeviceProcAddr( m_device, pName );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE PFN_vkVoidFunction Device::getProcAddr( const std::string & name,
+                                                            Dispatch const &    d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return d.vkGetDeviceProcAddr( m_device, name.c_str() );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    PhysicalDevice::createDevice( const VULKAN_HPP_NAMESPACE::DeviceCreateInfo *    pCreateInfo,
+                                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                  VULKAN_HPP_NAMESPACE::Device *                    pDevice,
+                                  Dispatch const &                                  d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkCreateDevice( m_physicalDevice,
+                                                  reinterpret_cast<const VkDeviceCreateInfo *>( pCreateInfo ),
+                                                  reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
+                                                  reinterpret_cast<VkDevice *>( pDevice ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::Device>::type
+                                          PhysicalDevice::createDevice( const DeviceCreateInfo &            createInfo,
+                                  Optional<const AllocationCallbacks> allocator,
+                                  Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::Device device;
+    Result                       result = static_cast<Result>(
+      d.vkCreateDevice( m_physicalDevice,
+                        reinterpret_cast<const VkDeviceCreateInfo *>( &createInfo ),
+                        reinterpret_cast<const VkAllocationCallbacks *>(
+                          static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                        reinterpret_cast<VkDevice *>( &device ) ) );
+    return createResultValue( result, device, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::createDevice" );
+  }
+
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Device, Dispatch>>::type
+    PhysicalDevice::createDeviceUnique( const DeviceCreateInfo &            createInfo,
+                                        Optional<const AllocationCallbacks> allocator,
+                                        Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::Device device;
+    Result                       result = static_cast<Result>(
+      d.vkCreateDevice( m_physicalDevice,
+                        reinterpret_cast<const VkDeviceCreateInfo *>( &createInfo ),
+                        reinterpret_cast<const VkAllocationCallbacks *>(
+                          static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                        reinterpret_cast<VkDevice *>( &device ) ) );
+    ObjectDestroy<NoParent, Dispatch> deleter( allocator, d );
+    return createResultValue<VULKAN_HPP_NAMESPACE::Device, Dispatch>(
+      result, device, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::createDeviceUnique", deleter );
+  }
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyDevice( m_device, reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( Optional<const AllocationCallbacks> allocator,
+                                          Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyDevice( m_device,
+                       reinterpret_cast<const VkAllocationCallbacks *>(
+                         static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
     enumerateInstanceExtensionProperties( const char *                                pLayerName,
@@ -101897,6 +102474,87 @@ namespace VULKAN_HPP_NAMESPACE
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    PhysicalDevice::enumerateDeviceExtensionProperties( const char *                                pLayerName,
+                                                        uint32_t *                                  pPropertyCount,
+                                                        VULKAN_HPP_NAMESPACE::ExtensionProperties * pProperties,
+                                                        Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkEnumerateDeviceExtensionProperties(
+      m_physicalDevice, pLayerName, pPropertyCount, reinterpret_cast<VkExtensionProperties *>( pProperties ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename ExtensionPropertiesAllocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
+    typename ResultValueType<std::vector<ExtensionProperties, ExtensionPropertiesAllocator>>::type
+    PhysicalDevice::enumerateDeviceExtensionProperties( Optional<const std::string> layerName,
+                                                        Dispatch const &            d ) const
+  {
+    std::vector<ExtensionProperties, ExtensionPropertiesAllocator> properties;
+    uint32_t                                                       propertyCount;
+    Result                                                         result;
+    do
+    {
+      result = static_cast<Result>( d.vkEnumerateDeviceExtensionProperties(
+        m_physicalDevice, layerName ? layerName->c_str() : nullptr, &propertyCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && propertyCount )
+      {
+        properties.resize( propertyCount );
+        result = static_cast<Result>(
+          d.vkEnumerateDeviceExtensionProperties( m_physicalDevice,
+                                                  layerName ? layerName->c_str() : nullptr,
+                                                  &propertyCount,
+                                                  reinterpret_cast<VkExtensionProperties *>( properties.data() ) ) );
+        VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) )
+    {
+      properties.resize( propertyCount );
+    }
+    return createResultValue(
+      result, properties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateDeviceExtensionProperties" );
+  }
+
+  template <typename ExtensionPropertiesAllocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, ExtensionProperties>::value, int>::type>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
+    typename ResultValueType<std::vector<ExtensionProperties, ExtensionPropertiesAllocator>>::type
+    PhysicalDevice::enumerateDeviceExtensionProperties( Optional<const std::string>    layerName,
+                                                        ExtensionPropertiesAllocator & extensionPropertiesAllocator,
+                                                        Dispatch const &               d ) const
+  {
+    std::vector<ExtensionProperties, ExtensionPropertiesAllocator> properties( extensionPropertiesAllocator );
+    uint32_t                                                       propertyCount;
+    Result                                                         result;
+    do
+    {
+      result = static_cast<Result>( d.vkEnumerateDeviceExtensionProperties(
+        m_physicalDevice, layerName ? layerName->c_str() : nullptr, &propertyCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && propertyCount )
+      {
+        properties.resize( propertyCount );
+        result = static_cast<Result>(
+          d.vkEnumerateDeviceExtensionProperties( m_physicalDevice,
+                                                  layerName ? layerName->c_str() : nullptr,
+                                                  &propertyCount,
+                                                  reinterpret_cast<VkExtensionProperties *>( properties.data() ) ) );
+        VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) )
+    {
+      properties.resize( propertyCount );
+    }
+    return createResultValue(
+      result, properties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateDeviceExtensionProperties" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
     enumerateInstanceLayerProperties( uint32_t *                              pPropertyCount,
@@ -101965,3302 +102623,152 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result enumerateInstanceVersion( uint32_t *       pApiVersion,
-                                                                          Dispatch const & d ) VULKAN_HPP_NOEXCEPT
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    PhysicalDevice::enumerateDeviceLayerProperties( uint32_t *                              pPropertyCount,
+                                                    VULKAN_HPP_NAMESPACE::LayerProperties * pProperties,
+                                                    Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
-    return static_cast<Result>( d.vkEnumerateInstanceVersion( pApiVersion ) );
+    return static_cast<Result>( d.vkEnumerateDeviceLayerProperties(
+      m_physicalDevice, pPropertyCount, reinterpret_cast<VkLayerProperties *>( pProperties ) ) );
   }
 
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<uint32_t>::type enumerateInstanceVersion( Dispatch const & d )
+  template <typename LayerPropertiesAllocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
+    typename ResultValueType<std::vector<LayerProperties, LayerPropertiesAllocator>>::type
+    PhysicalDevice::enumerateDeviceLayerProperties( Dispatch const & d ) const
   {
-    uint32_t apiVersion;
-    Result   result = static_cast<Result>( d.vkEnumerateInstanceVersion( &apiVersion ) );
-    return createResultValue( result, apiVersion, VULKAN_HPP_NAMESPACE_STRING "::enumerateInstanceVersion" );
+    std::vector<LayerProperties, LayerPropertiesAllocator> properties;
+    uint32_t                                               propertyCount;
+    Result                                                 result;
+    do
+    {
+      result = static_cast<Result>( d.vkEnumerateDeviceLayerProperties( m_physicalDevice, &propertyCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && propertyCount )
+      {
+        properties.resize( propertyCount );
+        result = static_cast<Result>( d.vkEnumerateDeviceLayerProperties(
+          m_physicalDevice, &propertyCount, reinterpret_cast<VkLayerProperties *>( properties.data() ) ) );
+        VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) )
+    {
+      properties.resize( propertyCount );
+    }
+    return createResultValue(
+      result, properties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateDeviceLayerProperties" );
+  }
+
+  template <typename LayerPropertiesAllocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, LayerProperties>::value, int>::type>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
+    typename ResultValueType<std::vector<LayerProperties, LayerPropertiesAllocator>>::type
+    PhysicalDevice::enumerateDeviceLayerProperties( LayerPropertiesAllocator & layerPropertiesAllocator,
+                                                    Dispatch const &           d ) const
+  {
+    std::vector<LayerProperties, LayerPropertiesAllocator> properties( layerPropertiesAllocator );
+    uint32_t                                               propertyCount;
+    Result                                                 result;
+    do
+    {
+      result = static_cast<Result>( d.vkEnumerateDeviceLayerProperties( m_physicalDevice, &propertyCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && propertyCount )
+      {
+        properties.resize( propertyCount );
+        result = static_cast<Result>( d.vkEnumerateDeviceLayerProperties(
+          m_physicalDevice, &propertyCount, reinterpret_cast<VkLayerProperties *>( properties.data() ) ) );
+        VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) )
+    {
+      properties.resize( propertyCount );
+    }
+    return createResultValue(
+      result, properties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateDeviceLayerProperties" );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result CommandBuffer::begin(
-    const VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo * pBeginInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  VULKAN_HPP_INLINE void Device::getQueue( uint32_t                      queueFamilyIndex,
+                                           uint32_t                      queueIndex,
+                                           VULKAN_HPP_NAMESPACE::Queue * pQueue,
+                                           Dispatch const &              d ) const VULKAN_HPP_NOEXCEPT
   {
-    return static_cast<Result>(
-      d.vkBeginCommandBuffer( m_commandBuffer, reinterpret_cast<const VkCommandBufferBeginInfo *>( pBeginInfo ) ) );
+    d.vkGetDeviceQueue( m_device, queueFamilyIndex, queueIndex, reinterpret_cast<VkQueue *>( pQueue ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Queue
+    Device::getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    VULKAN_HPP_NAMESPACE::Queue queue;
+    d.vkGetDeviceQueue( m_device, queueFamilyIndex, queueIndex, reinterpret_cast<VkQueue *>( &queue ) );
+    return queue;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Queue::submit( uint32_t                                 submitCount,
+                                                               const VULKAN_HPP_NAMESPACE::SubmitInfo * pSubmits,
+                                                               VULKAN_HPP_NAMESPACE::Fence              fence,
+                                                               Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkQueueSubmit(
+      m_queue, submitCount, reinterpret_cast<const VkSubmitInfo *>( pSubmits ), static_cast<VkFence>( fence ) ) );
   }
 
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
-    CommandBuffer::begin( const CommandBufferBeginInfo & beginInfo, Dispatch const & d ) const
-  {
-    Result result = static_cast<Result>(
-      d.vkBeginCommandBuffer( m_commandBuffer, reinterpret_cast<const VkCommandBufferBeginInfo *>( &beginInfo ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::begin" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::beginConditionalRenderingEXT(
-    const VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT * pConditionalRenderingBegin,
-    Dispatch const &                                               d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdBeginConditionalRenderingEXT(
-      m_commandBuffer, reinterpret_cast<const VkConditionalRenderingBeginInfoEXT *>( pConditionalRenderingBegin ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    CommandBuffer::beginConditionalRenderingEXT( const ConditionalRenderingBeginInfoEXT & conditionalRenderingBegin,
-                                                 Dispatch const &                         d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdBeginConditionalRenderingEXT(
-      m_commandBuffer, reinterpret_cast<const VkConditionalRenderingBeginInfoEXT *>( &conditionalRenderingBegin ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    CommandBuffer::beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo,
-                                            Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdBeginDebugUtilsLabelEXT( m_commandBuffer, reinterpret_cast<const VkDebugUtilsLabelEXT *>( pLabelInfo ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo,
-                                                                 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdBeginDebugUtilsLabelEXT( m_commandBuffer, reinterpret_cast<const VkDebugUtilsLabelEXT *>( &labelInfo ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::beginQuery( VULKAN_HPP_NAMESPACE::QueryPool         queryPool,
-                                                    uint32_t                                query,
-                                                    VULKAN_HPP_NAMESPACE::QueryControlFlags flags,
-                                                    Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdBeginQuery(
-      m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query, static_cast<VkQueryControlFlags>( flags ) );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::beginQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool         queryPool,
-                                                              uint32_t                                query,
-                                                              VULKAN_HPP_NAMESPACE::QueryControlFlags flags,
-                                                              uint32_t                                index,
-                                                              Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdBeginQueryIndexedEXT(
-      m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query, static_cast<VkQueryControlFlags>( flags ), index );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    CommandBuffer::beginRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo * pRenderPassBegin,
-                                    VULKAN_HPP_NAMESPACE::SubpassContents             contents,
-                                    Dispatch const &                                  d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdBeginRenderPass( m_commandBuffer,
-                            reinterpret_cast<const VkRenderPassBeginInfo *>( pRenderPassBegin ),
-                            static_cast<VkSubpassContents>( contents ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass( const RenderPassBeginInfo &           renderPassBegin,
-                                                         VULKAN_HPP_NAMESPACE::SubpassContents contents,
-                                                         Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdBeginRenderPass( m_commandBuffer,
-                            reinterpret_cast<const VkRenderPassBeginInfo *>( &renderPassBegin ),
-                            static_cast<VkSubpassContents>( contents ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    CommandBuffer::beginRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo * pRenderPassBegin,
-                                     const VULKAN_HPP_NAMESPACE::SubpassBeginInfo *    pSubpassBeginInfo,
-                                     Dispatch const &                                  d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdBeginRenderPass2( m_commandBuffer,
-                             reinterpret_cast<const VkRenderPassBeginInfo *>( pRenderPassBegin ),
-                             reinterpret_cast<const VkSubpassBeginInfo *>( pSubpassBeginInfo ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass2( const RenderPassBeginInfo & renderPassBegin,
-                                                          const SubpassBeginInfo &    subpassBeginInfo,
-                                                          Dispatch const &            d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdBeginRenderPass2( m_commandBuffer,
-                             reinterpret_cast<const VkRenderPassBeginInfo *>( &renderPassBegin ),
-                             reinterpret_cast<const VkSubpassBeginInfo *>( &subpassBeginInfo ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    CommandBuffer::beginRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo * pRenderPassBegin,
-                                        const VULKAN_HPP_NAMESPACE::SubpassBeginInfo *    pSubpassBeginInfo,
-                                        Dispatch const &                                  d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdBeginRenderPass2KHR( m_commandBuffer,
-                                reinterpret_cast<const VkRenderPassBeginInfo *>( pRenderPassBegin ),
-                                reinterpret_cast<const VkSubpassBeginInfo *>( pSubpassBeginInfo ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass2KHR( const RenderPassBeginInfo & renderPassBegin,
-                                                             const SubpassBeginInfo &    subpassBeginInfo,
-                                                             Dispatch const &            d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdBeginRenderPass2KHR( m_commandBuffer,
-                                reinterpret_cast<const VkRenderPassBeginInfo *>( &renderPassBegin ),
-                                reinterpret_cast<const VkSubpassBeginInfo *>( &subpassBeginInfo ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    CommandBuffer::beginTransformFeedbackEXT( uint32_t                                 firstCounterBuffer,
-                                              uint32_t                                 counterBufferCount,
-                                              const VULKAN_HPP_NAMESPACE::Buffer *     pCounterBuffers,
-                                              const VULKAN_HPP_NAMESPACE::DeviceSize * pCounterBufferOffsets,
-                                              Dispatch const &                         d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdBeginTransformFeedbackEXT( m_commandBuffer,
-                                      firstCounterBuffer,
-                                      counterBufferCount,
-                                      reinterpret_cast<const VkBuffer *>( pCounterBuffers ),
-                                      reinterpret_cast<const VkDeviceSize *>( pCounterBufferOffsets ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::beginTransformFeedbackEXT(
-    uint32_t                                                   firstCounterBuffer,
-    ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &     counterBuffers,
-    ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets,
-    Dispatch const &                                           d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
-  {
-#  ifdef VULKAN_HPP_NO_EXCEPTIONS
-    VULKAN_HPP_ASSERT( counterBufferOffsets.empty() || counterBuffers.size() == counterBufferOffsets.size() );
-#  else
-    if ( !counterBufferOffsets.empty() && counterBuffers.size() != counterBufferOffsets.size() )
-    {
-      throw LogicError(
-        VULKAN_HPP_NAMESPACE_STRING
-        "::CommandBuffer::beginTransformFeedbackEXT: counterBuffers.size() != counterBufferOffsets.size()" );
-    }
-#  endif /*VULKAN_HPP_NO_EXCEPTIONS*/
-
-    d.vkCmdBeginTransformFeedbackEXT( m_commandBuffer,
-                                      firstCounterBuffer,
-                                      counterBuffers.size(),
-                                      reinterpret_cast<const VkBuffer *>( counterBuffers.data() ),
-                                      reinterpret_cast<const VkDeviceSize *>( counterBufferOffsets.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#if defined( VK_ENABLE_BETA_EXTENSIONS )
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    CommandBuffer::beginVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR * pBeginInfo,
-                                        Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdBeginVideoCodingKHR( m_commandBuffer, reinterpret_cast<const VkVideoBeginCodingInfoKHR *>( pBeginInfo ) );
-  }
-
-#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::beginVideoCodingKHR( const VideoBeginCodingInfoKHR & beginInfo,
-                                                             Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdBeginVideoCodingKHR( m_commandBuffer, reinterpret_cast<const VkVideoBeginCodingInfoKHR *>( &beginInfo ) );
-  }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_ENABLE_BETA_EXTENSIONS*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorSets( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
-                                                            VULKAN_HPP_NAMESPACE::PipelineLayout    layout,
-                                                            uint32_t                                firstSet,
-                                                            uint32_t                                descriptorSetCount,
-                                                            const VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets,
-                                                            uint32_t         dynamicOffsetCount,
-                                                            const uint32_t * pDynamicOffsets,
-                                                            Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdBindDescriptorSets( m_commandBuffer,
-                               static_cast<VkPipelineBindPoint>( pipelineBindPoint ),
-                               static_cast<VkPipelineLayout>( layout ),
-                               firstSet,
-                               descriptorSetCount,
-                               reinterpret_cast<const VkDescriptorSet *>( pDescriptorSets ),
-                               dynamicOffsetCount,
-                               pDynamicOffsets );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    CommandBuffer::bindDescriptorSets( VULKAN_HPP_NAMESPACE::PipelineBindPoint                       pipelineBindPoint,
-                                       VULKAN_HPP_NAMESPACE::PipelineLayout                          layout,
-                                       uint32_t                                                      firstSet,
-                                       ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets,
-                                       ArrayProxy<const uint32_t> const &                            dynamicOffsets,
-                                       Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdBindDescriptorSets( m_commandBuffer,
-                               static_cast<VkPipelineBindPoint>( pipelineBindPoint ),
-                               static_cast<VkPipelineLayout>( layout ),
-                               firstSet,
-                               descriptorSets.size(),
-                               reinterpret_cast<const VkDescriptorSet *>( descriptorSets.data() ),
-                               dynamicOffsets.size(),
-                               dynamicOffsets.data() );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::bindIndexBuffer( VULKAN_HPP_NAMESPACE::Buffer     buffer,
-                                                         VULKAN_HPP_NAMESPACE::DeviceSize offset,
-                                                         VULKAN_HPP_NAMESPACE::IndexType  indexType,
-                                                         Dispatch const &                 d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdBindIndexBuffer( m_commandBuffer,
-                            static_cast<VkBuffer>( buffer ),
-                            static_cast<VkDeviceSize>( offset ),
-                            static_cast<VkIndexType>( indexType ) );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::bindPipeline( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
-                                                      VULKAN_HPP_NAMESPACE::Pipeline          pipeline,
-                                                      Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdBindPipeline(
-      m_commandBuffer, static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipeline>( pipeline ) );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    CommandBuffer::bindPipelineShaderGroupNV( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
-                                              VULKAN_HPP_NAMESPACE::Pipeline          pipeline,
-                                              uint32_t                                groupIndex,
-                                              Dispatch const &                        d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdBindPipelineShaderGroupNV( m_commandBuffer,
-                                      static_cast<VkPipelineBindPoint>( pipelineBindPoint ),
-                                      static_cast<VkPipeline>( pipeline ),
-                                      groupIndex );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::bindShadingRateImageNV( VULKAN_HPP_NAMESPACE::ImageView   imageView,
-                                                                VULKAN_HPP_NAMESPACE::ImageLayout imageLayout,
-                                                                Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdBindShadingRateImageNV(
-      m_commandBuffer, static_cast<VkImageView>( imageView ), static_cast<VkImageLayout>( imageLayout ) );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    CommandBuffer::bindTransformFeedbackBuffersEXT( uint32_t                                 firstBinding,
-                                                    uint32_t                                 bindingCount,
-                                                    const VULKAN_HPP_NAMESPACE::Buffer *     pBuffers,
-                                                    const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets,
-                                                    const VULKAN_HPP_NAMESPACE::DeviceSize * pSizes,
-                                                    Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdBindTransformFeedbackBuffersEXT( m_commandBuffer,
-                                            firstBinding,
-                                            bindingCount,
-                                            reinterpret_cast<const VkBuffer *>( pBuffers ),
-                                            reinterpret_cast<const VkDeviceSize *>( pOffsets ),
-                                            reinterpret_cast<const VkDeviceSize *>( pSizes ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    CommandBuffer::bindTransformFeedbackBuffersEXT( uint32_t                                               firstBinding,
-                                                    ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers,
-                                                    ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,
-                                                    ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes,
-                                                    Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
-  {
-#  ifdef VULKAN_HPP_NO_EXCEPTIONS
-    VULKAN_HPP_ASSERT( buffers.size() == offsets.size() );
-    VULKAN_HPP_ASSERT( sizes.empty() || buffers.size() == sizes.size() );
-#  else
-    if ( buffers.size() != offsets.size() )
-    {
-      throw LogicError( VULKAN_HPP_NAMESPACE_STRING
-                        "::CommandBuffer::bindTransformFeedbackBuffersEXT: buffers.size() != offsets.size()" );
-    }
-    if ( !sizes.empty() && buffers.size() != sizes.size() )
-    {
-      throw LogicError( VULKAN_HPP_NAMESPACE_STRING
-                        "::CommandBuffer::bindTransformFeedbackBuffersEXT: buffers.size() != sizes.size()" );
-    }
-#  endif /*VULKAN_HPP_NO_EXCEPTIONS*/
-
-    d.vkCmdBindTransformFeedbackBuffersEXT( m_commandBuffer,
-                                            firstBinding,
-                                            buffers.size(),
-                                            reinterpret_cast<const VkBuffer *>( buffers.data() ),
-                                            reinterpret_cast<const VkDeviceSize *>( offsets.data() ),
-                                            reinterpret_cast<const VkDeviceSize *>( sizes.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers( uint32_t                                 firstBinding,
-                                                           uint32_t                                 bindingCount,
-                                                           const VULKAN_HPP_NAMESPACE::Buffer *     pBuffers,
-                                                           const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets,
-                                                           Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdBindVertexBuffers( m_commandBuffer,
-                              firstBinding,
-                              bindingCount,
-                              reinterpret_cast<const VkBuffer *>( pBuffers ),
-                              reinterpret_cast<const VkDeviceSize *>( pOffsets ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    CommandBuffer::bindVertexBuffers( uint32_t                                                   firstBinding,
-                                      ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &     buffers,
-                                      ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,
-                                      Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
-  {
-#  ifdef VULKAN_HPP_NO_EXCEPTIONS
-    VULKAN_HPP_ASSERT( buffers.size() == offsets.size() );
-#  else
-    if ( buffers.size() != offsets.size() )
-    {
-      throw LogicError( VULKAN_HPP_NAMESPACE_STRING
-                        "::CommandBuffer::bindVertexBuffers: buffers.size() != offsets.size()" );
-    }
-#  endif /*VULKAN_HPP_NO_EXCEPTIONS*/
-
-    d.vkCmdBindVertexBuffers( m_commandBuffer,
-                              firstBinding,
-                              buffers.size(),
-                              reinterpret_cast<const VkBuffer *>( buffers.data() ),
-                              reinterpret_cast<const VkDeviceSize *>( offsets.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers2EXT( uint32_t                                 firstBinding,
-                                                               uint32_t                                 bindingCount,
-                                                               const VULKAN_HPP_NAMESPACE::Buffer *     pBuffers,
-                                                               const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets,
-                                                               const VULKAN_HPP_NAMESPACE::DeviceSize * pSizes,
-                                                               const VULKAN_HPP_NAMESPACE::DeviceSize * pStrides,
-                                                               Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdBindVertexBuffers2EXT( m_commandBuffer,
-                                  firstBinding,
-                                  bindingCount,
-                                  reinterpret_cast<const VkBuffer *>( pBuffers ),
-                                  reinterpret_cast<const VkDeviceSize *>( pOffsets ),
-                                  reinterpret_cast<const VkDeviceSize *>( pSizes ),
-                                  reinterpret_cast<const VkDeviceSize *>( pStrides ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    CommandBuffer::bindVertexBuffers2EXT( uint32_t                                                   firstBinding,
-                                          ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &     buffers,
-                                          ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,
-                                          ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes,
-                                          ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & strides,
-                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
-  {
-#  ifdef VULKAN_HPP_NO_EXCEPTIONS
-    VULKAN_HPP_ASSERT( buffers.size() == offsets.size() );
-    VULKAN_HPP_ASSERT( sizes.empty() || buffers.size() == sizes.size() );
-    VULKAN_HPP_ASSERT( strides.empty() || buffers.size() == strides.size() );
-#  else
-    if ( buffers.size() != offsets.size() )
-    {
-      throw LogicError( VULKAN_HPP_NAMESPACE_STRING
-                        "::CommandBuffer::bindVertexBuffers2EXT: buffers.size() != offsets.size()" );
-    }
-    if ( !sizes.empty() && buffers.size() != sizes.size() )
-    {
-      throw LogicError( VULKAN_HPP_NAMESPACE_STRING
-                        "::CommandBuffer::bindVertexBuffers2EXT: buffers.size() != sizes.size()" );
-    }
-    if ( !strides.empty() && buffers.size() != strides.size() )
-    {
-      throw LogicError( VULKAN_HPP_NAMESPACE_STRING
-                        "::CommandBuffer::bindVertexBuffers2EXT: buffers.size() != strides.size()" );
-    }
-#  endif /*VULKAN_HPP_NO_EXCEPTIONS*/
-
-    d.vkCmdBindVertexBuffers2EXT( m_commandBuffer,
-                                  firstBinding,
-                                  buffers.size(),
-                                  reinterpret_cast<const VkBuffer *>( buffers.data() ),
-                                  reinterpret_cast<const VkDeviceSize *>( offsets.data() ),
-                                  reinterpret_cast<const VkDeviceSize *>( sizes.data() ),
-                                  reinterpret_cast<const VkDeviceSize *>( strides.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::blitImage( VULKAN_HPP_NAMESPACE::Image             srcImage,
-                                                   VULKAN_HPP_NAMESPACE::ImageLayout       srcImageLayout,
-                                                   VULKAN_HPP_NAMESPACE::Image             dstImage,
-                                                   VULKAN_HPP_NAMESPACE::ImageLayout       dstImageLayout,
-                                                   uint32_t                                regionCount,
-                                                   const VULKAN_HPP_NAMESPACE::ImageBlit * pRegions,
-                                                   VULKAN_HPP_NAMESPACE::Filter            filter,
-                                                   Dispatch const &                        d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdBlitImage( m_commandBuffer,
-                      static_cast<VkImage>( srcImage ),
-                      static_cast<VkImageLayout>( srcImageLayout ),
-                      static_cast<VkImage>( dstImage ),
-                      static_cast<VkImageLayout>( dstImageLayout ),
-                      regionCount,
-                      reinterpret_cast<const VkImageBlit *>( pRegions ),
-                      static_cast<VkFilter>( filter ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::blitImage( VULKAN_HPP_NAMESPACE::Image       srcImage,
-                                                   VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout,
-                                                   VULKAN_HPP_NAMESPACE::Image       dstImage,
-                                                   VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,
-                                                   ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageBlit> const & regions,
-                                                   VULKAN_HPP_NAMESPACE::Filter                              filter,
-                                                   Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdBlitImage( m_commandBuffer,
-                      static_cast<VkImage>( srcImage ),
-                      static_cast<VkImageLayout>( srcImageLayout ),
-                      static_cast<VkImage>( dstImage ),
-                      static_cast<VkImageLayout>( dstImageLayout ),
-                      regions.size(),
-                      reinterpret_cast<const VkImageBlit *>( regions.data() ),
-                      static_cast<VkFilter>( filter ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::blitImage2KHR( const VULKAN_HPP_NAMESPACE::BlitImageInfo2KHR * pBlitImageInfo,
-                                                       Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdBlitImage2KHR( m_commandBuffer, reinterpret_cast<const VkBlitImageInfo2KHR *>( pBlitImageInfo ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::blitImage2KHR( const BlitImageInfo2KHR & blitImageInfo,
-                                                       Dispatch const &          d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdBlitImage2KHR( m_commandBuffer, reinterpret_cast<const VkBlitImageInfo2KHR *>( &blitImageInfo ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    CommandBuffer::buildAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV * pInfo,
-                                                 VULKAN_HPP_NAMESPACE::Buffer                              instanceData,
-                                                 VULKAN_HPP_NAMESPACE::DeviceSize              instanceOffset,
-                                                 VULKAN_HPP_NAMESPACE::Bool32                  update,
-                                                 VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst,
-                                                 VULKAN_HPP_NAMESPACE::AccelerationStructureNV src,
-                                                 VULKAN_HPP_NAMESPACE::Buffer                  scratch,
-                                                 VULKAN_HPP_NAMESPACE::DeviceSize              scratchOffset,
-                                                 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdBuildAccelerationStructureNV( m_commandBuffer,
-                                         reinterpret_cast<const VkAccelerationStructureInfoNV *>( pInfo ),
-                                         static_cast<VkBuffer>( instanceData ),
-                                         static_cast<VkDeviceSize>( instanceOffset ),
-                                         static_cast<VkBool32>( update ),
-                                         static_cast<VkAccelerationStructureNV>( dst ),
-                                         static_cast<VkAccelerationStructureNV>( src ),
-                                         static_cast<VkBuffer>( scratch ),
-                                         static_cast<VkDeviceSize>( scratchOffset ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructureNV( const AccelerationStructureInfoNV & info,
-                                                                      VULKAN_HPP_NAMESPACE::Buffer        instanceData,
-                                                                      VULKAN_HPP_NAMESPACE::DeviceSize instanceOffset,
-                                                                      VULKAN_HPP_NAMESPACE::Bool32     update,
-                                                                      VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst,
-                                                                      VULKAN_HPP_NAMESPACE::AccelerationStructureNV src,
-                                                                      VULKAN_HPP_NAMESPACE::Buffer     scratch,
-                                                                      VULKAN_HPP_NAMESPACE::DeviceSize scratchOffset,
-                                                                      Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdBuildAccelerationStructureNV( m_commandBuffer,
-                                         reinterpret_cast<const VkAccelerationStructureInfoNV *>( &info ),
-                                         static_cast<VkBuffer>( instanceData ),
-                                         static_cast<VkDeviceSize>( instanceOffset ),
-                                         static_cast<VkBool32>( update ),
-                                         static_cast<VkAccelerationStructureNV>( dst ),
-                                         static_cast<VkAccelerationStructureNV>( src ),
-                                         static_cast<VkBuffer>( scratch ),
-                                         static_cast<VkDeviceSize>( scratchOffset ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructuresIndirectKHR(
-    uint32_t                                                                infoCount,
-    const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR * pInfos,
-    const VULKAN_HPP_NAMESPACE::DeviceAddress *                             pIndirectDeviceAddresses,
-    const uint32_t *                                                        pIndirectStrides,
-    const uint32_t * const *                                                ppMaxPrimitiveCounts,
-    Dispatch const &                                                        d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdBuildAccelerationStructuresIndirectKHR(
-      m_commandBuffer,
-      infoCount,
-      reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( pInfos ),
-      reinterpret_cast<const VkDeviceAddress *>( pIndirectDeviceAddresses ),
-      pIndirectStrides,
-      ppMaxPrimitiveCounts );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructuresIndirectKHR(
-    ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos,
-    ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceAddress> const &                             indirectDeviceAddresses,
-    ArrayProxy<const uint32_t> const &                                                        indirectStrides,
-    ArrayProxy<const uint32_t * const> const &                                                pMaxPrimitiveCounts,
-    Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
-  {
-#  ifdef VULKAN_HPP_NO_EXCEPTIONS
-    VULKAN_HPP_ASSERT( infos.size() == indirectDeviceAddresses.size() );
-    VULKAN_HPP_ASSERT( infos.size() == indirectStrides.size() );
-    VULKAN_HPP_ASSERT( infos.size() == pMaxPrimitiveCounts.size() );
-#  else
-    if ( infos.size() != indirectDeviceAddresses.size() )
-    {
-      throw LogicError(
-        VULKAN_HPP_NAMESPACE_STRING
-        "::CommandBuffer::buildAccelerationStructuresIndirectKHR: infos.size() != indirectDeviceAddresses.size()" );
-    }
-    if ( infos.size() != indirectStrides.size() )
-    {
-      throw LogicError(
-        VULKAN_HPP_NAMESPACE_STRING
-        "::CommandBuffer::buildAccelerationStructuresIndirectKHR: infos.size() != indirectStrides.size()" );
-    }
-    if ( infos.size() != pMaxPrimitiveCounts.size() )
-    {
-      throw LogicError(
-        VULKAN_HPP_NAMESPACE_STRING
-        "::CommandBuffer::buildAccelerationStructuresIndirectKHR: infos.size() != pMaxPrimitiveCounts.size()" );
-    }
-#  endif /*VULKAN_HPP_NO_EXCEPTIONS*/
-
-    d.vkCmdBuildAccelerationStructuresIndirectKHR(
-      m_commandBuffer,
-      infos.size(),
-      reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( infos.data() ),
-      reinterpret_cast<const VkDeviceAddress *>( indirectDeviceAddresses.data() ),
-      indirectStrides.data(),
-      pMaxPrimitiveCounts.data() );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructuresKHR(
-    uint32_t                                                                     infoCount,
-    const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR *      pInfos,
-    const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos,
-    Dispatch const &                                                             d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdBuildAccelerationStructuresKHR(
-      m_commandBuffer,
-      infoCount,
-      reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( pInfos ),
-      reinterpret_cast<const VkAccelerationStructureBuildRangeInfoKHR * const *>( ppBuildRangeInfos ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructuresKHR(
-    ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const &      infos,
-    ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos,
-    Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
-  {
-#  ifdef VULKAN_HPP_NO_EXCEPTIONS
-    VULKAN_HPP_ASSERT( infos.size() == pBuildRangeInfos.size() );
-#  else
-    if ( infos.size() != pBuildRangeInfos.size() )
-    {
-      throw LogicError( VULKAN_HPP_NAMESPACE_STRING
-                        "::CommandBuffer::buildAccelerationStructuresKHR: infos.size() != pBuildRangeInfos.size()" );
-    }
-#  endif /*VULKAN_HPP_NO_EXCEPTIONS*/
-
-    d.vkCmdBuildAccelerationStructuresKHR(
-      m_commandBuffer,
-      infos.size(),
-      reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( infos.data() ),
-      reinterpret_cast<const VkAccelerationStructureBuildRangeInfoKHR * const *>( pBuildRangeInfos.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::clearAttachments( uint32_t                                      attachmentCount,
-                                                          const VULKAN_HPP_NAMESPACE::ClearAttachment * pAttachments,
-                                                          uint32_t                                      rectCount,
-                                                          const VULKAN_HPP_NAMESPACE::ClearRect *       pRects,
-                                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdClearAttachments( m_commandBuffer,
-                             attachmentCount,
-                             reinterpret_cast<const VkClearAttachment *>( pAttachments ),
-                             rectCount,
-                             reinterpret_cast<const VkClearRect *>( pRects ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    CommandBuffer::clearAttachments( ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearAttachment> const & attachments,
-                                     ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearRect> const &       rects,
-                                     Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdClearAttachments( m_commandBuffer,
-                             attachments.size(),
-                             reinterpret_cast<const VkClearAttachment *>( attachments.data() ),
-                             rects.size(),
-                             reinterpret_cast<const VkClearRect *>( rects.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::clearColorImage( VULKAN_HPP_NAMESPACE::Image                   image,
-                                                         VULKAN_HPP_NAMESPACE::ImageLayout             imageLayout,
-                                                         const VULKAN_HPP_NAMESPACE::ClearColorValue * pColor,
-                                                         uint32_t                                      rangeCount,
-                                                         const VULKAN_HPP_NAMESPACE::ImageSubresourceRange * pRanges,
-                                                         Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdClearColorImage( m_commandBuffer,
-                            static_cast<VkImage>( image ),
-                            static_cast<VkImageLayout>( imageLayout ),
-                            reinterpret_cast<const VkClearColorValue *>( pColor ),
-                            rangeCount,
-                            reinterpret_cast<const VkImageSubresourceRange *>( pRanges ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    CommandBuffer::clearColorImage( VULKAN_HPP_NAMESPACE::Image                                           image,
-                                    VULKAN_HPP_NAMESPACE::ImageLayout                                     imageLayout,
-                                    const ClearColorValue &                                               color,
-                                    ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceRange> const & ranges,
-                                    Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdClearColorImage( m_commandBuffer,
-                            static_cast<VkImage>( image ),
-                            static_cast<VkImageLayout>( imageLayout ),
-                            reinterpret_cast<const VkClearColorValue *>( &color ),
-                            ranges.size(),
-                            reinterpret_cast<const VkImageSubresourceRange *>( ranges.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    CommandBuffer::clearDepthStencilImage( VULKAN_HPP_NAMESPACE::Image                          image,
-                                           VULKAN_HPP_NAMESPACE::ImageLayout                    imageLayout,
-                                           const VULKAN_HPP_NAMESPACE::ClearDepthStencilValue * pDepthStencil,
-                                           uint32_t                                             rangeCount,
-                                           const VULKAN_HPP_NAMESPACE::ImageSubresourceRange *  pRanges,
-                                           Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdClearDepthStencilImage( m_commandBuffer,
-                                   static_cast<VkImage>( image ),
-                                   static_cast<VkImageLayout>( imageLayout ),
-                                   reinterpret_cast<const VkClearDepthStencilValue *>( pDepthStencil ),
-                                   rangeCount,
-                                   reinterpret_cast<const VkImageSubresourceRange *>( pRanges ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    CommandBuffer::clearDepthStencilImage( VULKAN_HPP_NAMESPACE::Image       image,
-                                           VULKAN_HPP_NAMESPACE::ImageLayout imageLayout,
-                                           const ClearDepthStencilValue &    depthStencil,
-                                           ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceRange> const & ranges,
-                                           Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdClearDepthStencilImage( m_commandBuffer,
-                                   static_cast<VkImage>( image ),
-                                   static_cast<VkImageLayout>( imageLayout ),
-                                   reinterpret_cast<const VkClearDepthStencilValue *>( &depthStencil ),
-                                   ranges.size(),
-                                   reinterpret_cast<const VkImageSubresourceRange *>( ranges.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#if defined( VK_ENABLE_BETA_EXTENSIONS )
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    CommandBuffer::controlVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR * pCodingControlInfo,
-                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdControlVideoCodingKHR( m_commandBuffer,
-                                  reinterpret_cast<const VkVideoCodingControlInfoKHR *>( pCodingControlInfo ) );
-  }
-
-#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::controlVideoCodingKHR( const VideoCodingControlInfoKHR & codingControlInfo,
-                                                               Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdControlVideoCodingKHR( m_commandBuffer,
-                                  reinterpret_cast<const VkVideoCodingControlInfoKHR *>( &codingControlInfo ) );
-  }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_ENABLE_BETA_EXTENSIONS*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    CommandBuffer::copyAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR * pInfo,
-                                                 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdCopyAccelerationStructureKHR( m_commandBuffer,
-                                         reinterpret_cast<const VkCopyAccelerationStructureInfoKHR *>( pInfo ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureKHR( const CopyAccelerationStructureInfoKHR & info,
-                                                                      Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdCopyAccelerationStructureKHR( m_commandBuffer,
-                                         reinterpret_cast<const VkCopyAccelerationStructureInfoKHR *>( &info ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    CommandBuffer::copyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV          dst,
-                                                VULKAN_HPP_NAMESPACE::AccelerationStructureNV          src,
-                                                VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR mode,
-                                                Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdCopyAccelerationStructureNV( m_commandBuffer,
-                                        static_cast<VkAccelerationStructureNV>( dst ),
-                                        static_cast<VkAccelerationStructureNV>( src ),
-                                        static_cast<VkCopyAccelerationStructureModeKHR>( mode ) );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureToMemoryKHR(
-    const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR * pInfo,
-    Dispatch const &                                                       d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdCopyAccelerationStructureToMemoryKHR(
-      m_commandBuffer, reinterpret_cast<const VkCopyAccelerationStructureToMemoryInfoKHR *>( pInfo ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    CommandBuffer::copyAccelerationStructureToMemoryKHR( const CopyAccelerationStructureToMemoryInfoKHR & info,
-                                                         Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdCopyAccelerationStructureToMemoryKHR(
-      m_commandBuffer, reinterpret_cast<const VkCopyAccelerationStructureToMemoryInfoKHR *>( &info ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::copyBuffer( VULKAN_HPP_NAMESPACE::Buffer             srcBuffer,
-                                                    VULKAN_HPP_NAMESPACE::Buffer             dstBuffer,
-                                                    uint32_t                                 regionCount,
-                                                    const VULKAN_HPP_NAMESPACE::BufferCopy * pRegions,
-                                                    Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdCopyBuffer( m_commandBuffer,
-                       static_cast<VkBuffer>( srcBuffer ),
-                       static_cast<VkBuffer>( dstBuffer ),
-                       regionCount,
-                       reinterpret_cast<const VkBufferCopy *>( pRegions ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::copyBuffer( VULKAN_HPP_NAMESPACE::Buffer srcBuffer,
-                                                    VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
-                                                    ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferCopy> const & regions,
-                                                    Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdCopyBuffer( m_commandBuffer,
-                       static_cast<VkBuffer>( srcBuffer ),
-                       static_cast<VkBuffer>( dstBuffer ),
-                       regions.size(),
-                       reinterpret_cast<const VkBufferCopy *>( regions.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    CommandBuffer::copyBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2KHR * pCopyBufferInfo,
-                                   Dispatch const &                                 d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdCopyBuffer2KHR( m_commandBuffer, reinterpret_cast<const VkCopyBufferInfo2KHR *>( pCopyBufferInfo ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::copyBuffer2KHR( const CopyBufferInfo2KHR & copyBufferInfo,
-                                                        Dispatch const &           d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdCopyBuffer2KHR( m_commandBuffer, reinterpret_cast<const VkCopyBufferInfo2KHR *>( &copyBufferInfo ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage( VULKAN_HPP_NAMESPACE::Buffer                  srcBuffer,
-                                                           VULKAN_HPP_NAMESPACE::Image                   dstImage,
-                                                           VULKAN_HPP_NAMESPACE::ImageLayout             dstImageLayout,
-                                                           uint32_t                                      regionCount,
-                                                           const VULKAN_HPP_NAMESPACE::BufferImageCopy * pRegions,
-                                                           Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdCopyBufferToImage( m_commandBuffer,
-                              static_cast<VkBuffer>( srcBuffer ),
-                              static_cast<VkImage>( dstImage ),
-                              static_cast<VkImageLayout>( dstImageLayout ),
-                              regionCount,
-                              reinterpret_cast<const VkBufferImageCopy *>( pRegions ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    CommandBuffer::copyBufferToImage( VULKAN_HPP_NAMESPACE::Buffer                                    srcBuffer,
-                                      VULKAN_HPP_NAMESPACE::Image                                     dstImage,
-                                      VULKAN_HPP_NAMESPACE::ImageLayout                               dstImageLayout,
-                                      ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions,
-                                      Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdCopyBufferToImage( m_commandBuffer,
-                              static_cast<VkBuffer>( srcBuffer ),
-                              static_cast<VkImage>( dstImage ),
-                              static_cast<VkImageLayout>( dstImageLayout ),
-                              regions.size(),
-                              reinterpret_cast<const VkBufferImageCopy *>( regions.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage2KHR(
-    const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2KHR * pCopyBufferToImageInfo,
-    Dispatch const &                                        d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdCopyBufferToImage2KHR( m_commandBuffer,
-                                  reinterpret_cast<const VkCopyBufferToImageInfo2KHR *>( pCopyBufferToImageInfo ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage2KHR( const CopyBufferToImageInfo2KHR & copyBufferToImageInfo,
-                                                               Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdCopyBufferToImage2KHR( m_commandBuffer,
-                                  reinterpret_cast<const VkCopyBufferToImageInfo2KHR *>( &copyBufferToImageInfo ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::copyImage( VULKAN_HPP_NAMESPACE::Image             srcImage,
-                                                   VULKAN_HPP_NAMESPACE::ImageLayout       srcImageLayout,
-                                                   VULKAN_HPP_NAMESPACE::Image             dstImage,
-                                                   VULKAN_HPP_NAMESPACE::ImageLayout       dstImageLayout,
-                                                   uint32_t                                regionCount,
-                                                   const VULKAN_HPP_NAMESPACE::ImageCopy * pRegions,
-                                                   Dispatch const &                        d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdCopyImage( m_commandBuffer,
-                      static_cast<VkImage>( srcImage ),
-                      static_cast<VkImageLayout>( srcImageLayout ),
-                      static_cast<VkImage>( dstImage ),
-                      static_cast<VkImageLayout>( dstImageLayout ),
-                      regionCount,
-                      reinterpret_cast<const VkImageCopy *>( pRegions ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::copyImage( VULKAN_HPP_NAMESPACE::Image       srcImage,
-                                                   VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout,
-                                                   VULKAN_HPP_NAMESPACE::Image       dstImage,
-                                                   VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,
-                                                   ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageCopy> const & regions,
-                                                   Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdCopyImage( m_commandBuffer,
-                      static_cast<VkImage>( srcImage ),
-                      static_cast<VkImageLayout>( srcImageLayout ),
-                      static_cast<VkImage>( dstImage ),
-                      static_cast<VkImageLayout>( dstImageLayout ),
-                      regions.size(),
-                      reinterpret_cast<const VkImageCopy *>( regions.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::copyImage2KHR( const VULKAN_HPP_NAMESPACE::CopyImageInfo2KHR * pCopyImageInfo,
-                                                       Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdCopyImage2KHR( m_commandBuffer, reinterpret_cast<const VkCopyImageInfo2KHR *>( pCopyImageInfo ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::copyImage2KHR( const CopyImageInfo2KHR & copyImageInfo,
-                                                       Dispatch const &          d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdCopyImage2KHR( m_commandBuffer, reinterpret_cast<const VkCopyImageInfo2KHR *>( &copyImageInfo ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer( VULKAN_HPP_NAMESPACE::Image                   srcImage,
-                                                           VULKAN_HPP_NAMESPACE::ImageLayout             srcImageLayout,
-                                                           VULKAN_HPP_NAMESPACE::Buffer                  dstBuffer,
-                                                           uint32_t                                      regionCount,
-                                                           const VULKAN_HPP_NAMESPACE::BufferImageCopy * pRegions,
-                                                           Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdCopyImageToBuffer( m_commandBuffer,
-                              static_cast<VkImage>( srcImage ),
-                              static_cast<VkImageLayout>( srcImageLayout ),
-                              static_cast<VkBuffer>( dstBuffer ),
-                              regionCount,
-                              reinterpret_cast<const VkBufferImageCopy *>( pRegions ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    CommandBuffer::copyImageToBuffer( VULKAN_HPP_NAMESPACE::Image                                     srcImage,
-                                      VULKAN_HPP_NAMESPACE::ImageLayout                               srcImageLayout,
-                                      VULKAN_HPP_NAMESPACE::Buffer                                    dstBuffer,
-                                      ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions,
-                                      Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdCopyImageToBuffer( m_commandBuffer,
-                              static_cast<VkImage>( srcImage ),
-                              static_cast<VkImageLayout>( srcImageLayout ),
-                              static_cast<VkBuffer>( dstBuffer ),
-                              regions.size(),
-                              reinterpret_cast<const VkBufferImageCopy *>( regions.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer2KHR(
-    const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2KHR * pCopyImageToBufferInfo,
-    Dispatch const &                                        d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdCopyImageToBuffer2KHR( m_commandBuffer,
-                                  reinterpret_cast<const VkCopyImageToBufferInfo2KHR *>( pCopyImageToBufferInfo ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer2KHR( const CopyImageToBufferInfo2KHR & copyImageToBufferInfo,
-                                                               Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdCopyImageToBuffer2KHR( m_commandBuffer,
-                                  reinterpret_cast<const VkCopyImageToBufferInfo2KHR *>( &copyImageToBufferInfo ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::copyMemoryToAccelerationStructureKHR(
-    const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR * pInfo,
-    Dispatch const &                                                       d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdCopyMemoryToAccelerationStructureKHR(
-      m_commandBuffer, reinterpret_cast<const VkCopyMemoryToAccelerationStructureInfoKHR *>( pInfo ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    CommandBuffer::copyMemoryToAccelerationStructureKHR( const CopyMemoryToAccelerationStructureInfoKHR & info,
-                                                         Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdCopyMemoryToAccelerationStructureKHR(
-      m_commandBuffer, reinterpret_cast<const VkCopyMemoryToAccelerationStructureInfoKHR *>( &info ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::copyQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool        queryPool,
-                                                              uint32_t                               firstQuery,
-                                                              uint32_t                               queryCount,
-                                                              VULKAN_HPP_NAMESPACE::Buffer           dstBuffer,
-                                                              VULKAN_HPP_NAMESPACE::DeviceSize       dstOffset,
-                                                              VULKAN_HPP_NAMESPACE::DeviceSize       stride,
-                                                              VULKAN_HPP_NAMESPACE::QueryResultFlags flags,
-                                                              Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdCopyQueryPoolResults( m_commandBuffer,
-                                 static_cast<VkQueryPool>( queryPool ),
-                                 firstQuery,
-                                 queryCount,
-                                 static_cast<VkBuffer>( dstBuffer ),
-                                 static_cast<VkDeviceSize>( dstOffset ),
-                                 static_cast<VkDeviceSize>( stride ),
-                                 static_cast<VkQueryResultFlags>( flags ) );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::cuLaunchKernelNVX( const VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX * pLaunchInfo,
-                                                           Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdCuLaunchKernelNVX( m_commandBuffer, reinterpret_cast<const VkCuLaunchInfoNVX *>( pLaunchInfo ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::cuLaunchKernelNVX( const CuLaunchInfoNVX & launchInfo,
-                                                           Dispatch const &        d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdCuLaunchKernelNVX( m_commandBuffer, reinterpret_cast<const VkCuLaunchInfoNVX *>( &launchInfo ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    CommandBuffer::debugMarkerBeginEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT * pMarkerInfo,
-                                        Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdDebugMarkerBeginEXT( m_commandBuffer, reinterpret_cast<const VkDebugMarkerMarkerInfoEXT *>( pMarkerInfo ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT & markerInfo,
-                                                             Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdDebugMarkerBeginEXT( m_commandBuffer, reinterpret_cast<const VkDebugMarkerMarkerInfoEXT *>( &markerInfo ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::debugMarkerEndEXT( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdDebugMarkerEndEXT( m_commandBuffer );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    CommandBuffer::debugMarkerInsertEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT * pMarkerInfo,
-                                         Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdDebugMarkerInsertEXT( m_commandBuffer, reinterpret_cast<const VkDebugMarkerMarkerInfoEXT *>( pMarkerInfo ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::debugMarkerInsertEXT( const DebugMarkerMarkerInfoEXT & markerInfo,
-                                                              Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdDebugMarkerInsertEXT( m_commandBuffer, reinterpret_cast<const VkDebugMarkerMarkerInfoEXT *>( &markerInfo ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#if defined( VK_ENABLE_BETA_EXTENSIONS )
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::decodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR * pFrameInfo,
-                                                        Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdDecodeVideoKHR( m_commandBuffer, reinterpret_cast<const VkVideoDecodeInfoKHR *>( pFrameInfo ) );
-  }
-
-#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::decodeVideoKHR( const VideoDecodeInfoKHR & frameInfo,
-                                                        Dispatch const &           d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdDecodeVideoKHR( m_commandBuffer, reinterpret_cast<const VkVideoDecodeInfoKHR *>( &frameInfo ) );
-  }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_ENABLE_BETA_EXTENSIONS*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::dispatch( uint32_t         groupCountX,
-                                                  uint32_t         groupCountY,
-                                                  uint32_t         groupCountZ,
-                                                  Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdDispatch( m_commandBuffer, groupCountX, groupCountY, groupCountZ );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::dispatchBase( uint32_t         baseGroupX,
-                                                      uint32_t         baseGroupY,
-                                                      uint32_t         baseGroupZ,
-                                                      uint32_t         groupCountX,
-                                                      uint32_t         groupCountY,
-                                                      uint32_t         groupCountZ,
-                                                      Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdDispatchBase( m_commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::dispatchBaseKHR( uint32_t         baseGroupX,
-                                                         uint32_t         baseGroupY,
-                                                         uint32_t         baseGroupZ,
-                                                         uint32_t         groupCountX,
-                                                         uint32_t         groupCountY,
-                                                         uint32_t         groupCountZ,
-                                                         Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdDispatchBaseKHR(
-      m_commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::dispatchIndirect( VULKAN_HPP_NAMESPACE::Buffer     buffer,
-                                                          VULKAN_HPP_NAMESPACE::DeviceSize offset,
-                                                          Dispatch const &                 d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdDispatchIndirect( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ) );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::draw( uint32_t         vertexCount,
-                                              uint32_t         instanceCount,
-                                              uint32_t         firstVertex,
-                                              uint32_t         firstInstance,
-                                              Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdDraw( m_commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::drawIndexed( uint32_t         indexCount,
-                                                     uint32_t         instanceCount,
-                                                     uint32_t         firstIndex,
-                                                     int32_t          vertexOffset,
-                                                     uint32_t         firstInstance,
-                                                     Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdDrawIndexed( m_commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirect( VULKAN_HPP_NAMESPACE::Buffer     buffer,
-                                                             VULKAN_HPP_NAMESPACE::DeviceSize offset,
-                                                             uint32_t                         drawCount,
-                                                             uint32_t                         stride,
-                                                             Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdDrawIndexedIndirect(
-      m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), drawCount, stride );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCount( VULKAN_HPP_NAMESPACE::Buffer     buffer,
-                                                                  VULKAN_HPP_NAMESPACE::DeviceSize offset,
-                                                                  VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
-                                                                  VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
-                                                                  uint32_t                         maxDrawCount,
-                                                                  uint32_t                         stride,
-                                                                  Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdDrawIndexedIndirectCount( m_commandBuffer,
-                                     static_cast<VkBuffer>( buffer ),
-                                     static_cast<VkDeviceSize>( offset ),
-                                     static_cast<VkBuffer>( countBuffer ),
-                                     static_cast<VkDeviceSize>( countBufferOffset ),
-                                     maxDrawCount,
-                                     stride );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer     buffer,
-                                                                     VULKAN_HPP_NAMESPACE::DeviceSize offset,
-                                                                     VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
-                                                                     VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
-                                                                     uint32_t                         maxDrawCount,
-                                                                     uint32_t                         stride,
-                                                                     Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdDrawIndexedIndirectCountAMD( m_commandBuffer,
-                                        static_cast<VkBuffer>( buffer ),
-                                        static_cast<VkDeviceSize>( offset ),
-                                        static_cast<VkBuffer>( countBuffer ),
-                                        static_cast<VkDeviceSize>( countBufferOffset ),
-                                        maxDrawCount,
-                                        stride );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer     buffer,
-                                                                     VULKAN_HPP_NAMESPACE::DeviceSize offset,
-                                                                     VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
-                                                                     VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
-                                                                     uint32_t                         maxDrawCount,
-                                                                     uint32_t                         stride,
-                                                                     Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdDrawIndexedIndirectCountKHR( m_commandBuffer,
-                                        static_cast<VkBuffer>( buffer ),
-                                        static_cast<VkDeviceSize>( offset ),
-                                        static_cast<VkBuffer>( countBuffer ),
-                                        static_cast<VkDeviceSize>( countBufferOffset ),
-                                        maxDrawCount,
-                                        stride );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::drawIndirect( VULKAN_HPP_NAMESPACE::Buffer     buffer,
-                                                      VULKAN_HPP_NAMESPACE::DeviceSize offset,
-                                                      uint32_t                         drawCount,
-                                                      uint32_t                         stride,
-                                                      Dispatch const &                 d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdDrawIndirect(
-      m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), drawCount, stride );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::drawIndirectByteCountEXT( uint32_t                         instanceCount,
-                                                                  uint32_t                         firstInstance,
-                                                                  VULKAN_HPP_NAMESPACE::Buffer     counterBuffer,
-                                                                  VULKAN_HPP_NAMESPACE::DeviceSize counterBufferOffset,
-                                                                  uint32_t                         counterOffset,
-                                                                  uint32_t                         vertexStride,
-                                                                  Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdDrawIndirectByteCountEXT( m_commandBuffer,
-                                     instanceCount,
-                                     firstInstance,
-                                     static_cast<VkBuffer>( counterBuffer ),
-                                     static_cast<VkDeviceSize>( counterBufferOffset ),
-                                     counterOffset,
-                                     vertexStride );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCount( VULKAN_HPP_NAMESPACE::Buffer     buffer,
-                                                           VULKAN_HPP_NAMESPACE::DeviceSize offset,
-                                                           VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
-                                                           VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
-                                                           uint32_t                         maxDrawCount,
-                                                           uint32_t                         stride,
-                                                           Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdDrawIndirectCount( m_commandBuffer,
-                              static_cast<VkBuffer>( buffer ),
-                              static_cast<VkDeviceSize>( offset ),
-                              static_cast<VkBuffer>( countBuffer ),
-                              static_cast<VkDeviceSize>( countBufferOffset ),
-                              maxDrawCount,
-                              stride );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer     buffer,
-                                                              VULKAN_HPP_NAMESPACE::DeviceSize offset,
-                                                              VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
-                                                              VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
-                                                              uint32_t                         maxDrawCount,
-                                                              uint32_t                         stride,
-                                                              Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdDrawIndirectCountAMD( m_commandBuffer,
-                                 static_cast<VkBuffer>( buffer ),
-                                 static_cast<VkDeviceSize>( offset ),
-                                 static_cast<VkBuffer>( countBuffer ),
-                                 static_cast<VkDeviceSize>( countBufferOffset ),
-                                 maxDrawCount,
-                                 stride );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer     buffer,
-                                                              VULKAN_HPP_NAMESPACE::DeviceSize offset,
-                                                              VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
-                                                              VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
-                                                              uint32_t                         maxDrawCount,
-                                                              uint32_t                         stride,
-                                                              Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdDrawIndirectCountKHR( m_commandBuffer,
-                                 static_cast<VkBuffer>( buffer ),
-                                 static_cast<VkDeviceSize>( offset ),
-                                 static_cast<VkBuffer>( countBuffer ),
-                                 static_cast<VkDeviceSize>( countBufferOffset ),
-                                 maxDrawCount,
-                                 stride );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    CommandBuffer::drawMeshTasksIndirectCountNV( VULKAN_HPP_NAMESPACE::Buffer     buffer,
-                                                 VULKAN_HPP_NAMESPACE::DeviceSize offset,
-                                                 VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
-                                                 VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
-                                                 uint32_t                         maxDrawCount,
-                                                 uint32_t                         stride,
-                                                 Dispatch const &                 d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdDrawMeshTasksIndirectCountNV( m_commandBuffer,
-                                         static_cast<VkBuffer>( buffer ),
-                                         static_cast<VkDeviceSize>( offset ),
-                                         static_cast<VkBuffer>( countBuffer ),
-                                         static_cast<VkDeviceSize>( countBufferOffset ),
-                                         maxDrawCount,
-                                         stride );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectNV( VULKAN_HPP_NAMESPACE::Buffer     buffer,
-                                                                 VULKAN_HPP_NAMESPACE::DeviceSize offset,
-                                                                 uint32_t                         drawCount,
-                                                                 uint32_t                         stride,
-                                                                 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdDrawMeshTasksIndirectNV(
-      m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), drawCount, stride );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksNV( uint32_t         taskCount,
-                                                         uint32_t         firstTask,
-                                                         Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdDrawMeshTasksNV( m_commandBuffer, taskCount, firstTask );
-  }
-
-#if defined( VK_ENABLE_BETA_EXTENSIONS )
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::encodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR * pEncodeInfo,
-                                                        Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdEncodeVideoKHR( m_commandBuffer, reinterpret_cast<const VkVideoEncodeInfoKHR *>( pEncodeInfo ) );
-  }
-
-#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::encodeVideoKHR( const VideoEncodeInfoKHR & encodeInfo,
-                                                        Dispatch const &           d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdEncodeVideoKHR( m_commandBuffer, reinterpret_cast<const VkVideoEncodeInfoKHR *>( &encodeInfo ) );
-  }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_ENABLE_BETA_EXTENSIONS*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::endConditionalRenderingEXT( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdEndConditionalRenderingEXT( m_commandBuffer );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::endDebugUtilsLabelEXT( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdEndDebugUtilsLabelEXT( m_commandBuffer );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::endQuery( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
-                                                  uint32_t                        query,
-                                                  Dispatch const &                d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdEndQuery( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::endQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
-                                                            uint32_t                        query,
-                                                            uint32_t                        index,
-                                                            Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdEndQueryIndexedEXT( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query, index );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::endRenderPass( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdEndRenderPass( m_commandBuffer );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2( const VULKAN_HPP_NAMESPACE::SubpassEndInfo * pSubpassEndInfo,
-                                                        Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdEndRenderPass2( m_commandBuffer, reinterpret_cast<const VkSubpassEndInfo *>( pSubpassEndInfo ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2( const SubpassEndInfo & subpassEndInfo,
-                                                        Dispatch const &       d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdEndRenderPass2( m_commandBuffer, reinterpret_cast<const VkSubpassEndInfo *>( &subpassEndInfo ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2KHR( const VULKAN_HPP_NAMESPACE::SubpassEndInfo * pSubpassEndInfo,
-                                                           Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdEndRenderPass2KHR( m_commandBuffer, reinterpret_cast<const VkSubpassEndInfo *>( pSubpassEndInfo ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2KHR( const SubpassEndInfo & subpassEndInfo,
-                                                           Dispatch const &       d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdEndRenderPass2KHR( m_commandBuffer, reinterpret_cast<const VkSubpassEndInfo *>( &subpassEndInfo ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    CommandBuffer::endTransformFeedbackEXT( uint32_t                                 firstCounterBuffer,
-                                            uint32_t                                 counterBufferCount,
-                                            const VULKAN_HPP_NAMESPACE::Buffer *     pCounterBuffers,
-                                            const VULKAN_HPP_NAMESPACE::DeviceSize * pCounterBufferOffsets,
-                                            Dispatch const &                         d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdEndTransformFeedbackEXT( m_commandBuffer,
-                                    firstCounterBuffer,
-                                    counterBufferCount,
-                                    reinterpret_cast<const VkBuffer *>( pCounterBuffers ),
-                                    reinterpret_cast<const VkDeviceSize *>( pCounterBufferOffsets ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::endTransformFeedbackEXT(
-    uint32_t                                                   firstCounterBuffer,
-    ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &     counterBuffers,
-    ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets,
-    Dispatch const &                                           d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
-  {
-#  ifdef VULKAN_HPP_NO_EXCEPTIONS
-    VULKAN_HPP_ASSERT( counterBufferOffsets.empty() || counterBuffers.size() == counterBufferOffsets.size() );
-#  else
-    if ( !counterBufferOffsets.empty() && counterBuffers.size() != counterBufferOffsets.size() )
-    {
-      throw LogicError(
-        VULKAN_HPP_NAMESPACE_STRING
-        "::CommandBuffer::endTransformFeedbackEXT: counterBuffers.size() != counterBufferOffsets.size()" );
-    }
-#  endif /*VULKAN_HPP_NO_EXCEPTIONS*/
-
-    d.vkCmdEndTransformFeedbackEXT( m_commandBuffer,
-                                    firstCounterBuffer,
-                                    counterBuffers.size(),
-                                    reinterpret_cast<const VkBuffer *>( counterBuffers.data() ),
-                                    reinterpret_cast<const VkDeviceSize *>( counterBufferOffsets.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#if defined( VK_ENABLE_BETA_EXTENSIONS )
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    CommandBuffer::endVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR * pEndCodingInfo,
-                                      Dispatch const &                                    d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdEndVideoCodingKHR( m_commandBuffer, reinterpret_cast<const VkVideoEndCodingInfoKHR *>( pEndCodingInfo ) );
-  }
-
-#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::endVideoCodingKHR( const VideoEndCodingInfoKHR & endCodingInfo,
-                                                           Dispatch const &              d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdEndVideoCodingKHR( m_commandBuffer, reinterpret_cast<const VkVideoEndCodingInfoKHR *>( &endCodingInfo ) );
-  }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_ENABLE_BETA_EXTENSIONS*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::executeCommands( uint32_t                                    commandBufferCount,
-                                                         const VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers,
-                                                         Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdExecuteCommands(
-      m_commandBuffer, commandBufferCount, reinterpret_cast<const VkCommandBuffer *>( pCommandBuffers ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    CommandBuffer::executeCommands( ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers,
-                                    Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdExecuteCommands(
-      m_commandBuffer, commandBuffers.size(), reinterpret_cast<const VkCommandBuffer *>( commandBuffers.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::executeGeneratedCommandsNV(
-    VULKAN_HPP_NAMESPACE::Bool32                          isPreprocessed,
-    const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV * pGeneratedCommandsInfo,
-    Dispatch const &                                      d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdExecuteGeneratedCommandsNV( m_commandBuffer,
-                                       static_cast<VkBool32>( isPreprocessed ),
-                                       reinterpret_cast<const VkGeneratedCommandsInfoNV *>( pGeneratedCommandsInfo ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    CommandBuffer::executeGeneratedCommandsNV( VULKAN_HPP_NAMESPACE::Bool32    isPreprocessed,
-                                               const GeneratedCommandsInfoNV & generatedCommandsInfo,
-                                               Dispatch const &                d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdExecuteGeneratedCommandsNV( m_commandBuffer,
-                                       static_cast<VkBool32>( isPreprocessed ),
-                                       reinterpret_cast<const VkGeneratedCommandsInfoNV *>( &generatedCommandsInfo ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::fillBuffer( VULKAN_HPP_NAMESPACE::Buffer     dstBuffer,
-                                                    VULKAN_HPP_NAMESPACE::DeviceSize dstOffset,
-                                                    VULKAN_HPP_NAMESPACE::DeviceSize size,
-                                                    uint32_t                         data,
-                                                    Dispatch const &                 d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdFillBuffer( m_commandBuffer,
-                       static_cast<VkBuffer>( dstBuffer ),
-                       static_cast<VkDeviceSize>( dstOffset ),
-                       static_cast<VkDeviceSize>( size ),
-                       data );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    CommandBuffer::insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo,
-                                             Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdInsertDebugUtilsLabelEXT( m_commandBuffer, reinterpret_cast<const VkDebugUtilsLabelEXT *>( pLabelInfo ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo,
-                                                                  Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdInsertDebugUtilsLabelEXT( m_commandBuffer, reinterpret_cast<const VkDebugUtilsLabelEXT *>( &labelInfo ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::nextSubpass( VULKAN_HPP_NAMESPACE::SubpassContents contents,
-                                                     Dispatch const &                      d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdNextSubpass( m_commandBuffer, static_cast<VkSubpassContents>( contents ) );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo * pSubpassBeginInfo,
-                                                      const VULKAN_HPP_NAMESPACE::SubpassEndInfo *   pSubpassEndInfo,
-                                                      Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdNextSubpass2( m_commandBuffer,
-                         reinterpret_cast<const VkSubpassBeginInfo *>( pSubpassBeginInfo ),
-                         reinterpret_cast<const VkSubpassEndInfo *>( pSubpassEndInfo ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2( const SubpassBeginInfo & subpassBeginInfo,
-                                                      const SubpassEndInfo &   subpassEndInfo,
-                                                      Dispatch const &         d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdNextSubpass2( m_commandBuffer,
-                         reinterpret_cast<const VkSubpassBeginInfo *>( &subpassBeginInfo ),
-                         reinterpret_cast<const VkSubpassEndInfo *>( &subpassEndInfo ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    CommandBuffer::nextSubpass2KHR( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo * pSubpassBeginInfo,
-                                    const VULKAN_HPP_NAMESPACE::SubpassEndInfo *   pSubpassEndInfo,
-                                    Dispatch const &                               d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdNextSubpass2KHR( m_commandBuffer,
-                            reinterpret_cast<const VkSubpassBeginInfo *>( pSubpassBeginInfo ),
-                            reinterpret_cast<const VkSubpassEndInfo *>( pSubpassEndInfo ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2KHR( const SubpassBeginInfo & subpassBeginInfo,
-                                                         const SubpassEndInfo &   subpassEndInfo,
-                                                         Dispatch const &         d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdNextSubpass2KHR( m_commandBuffer,
-                            reinterpret_cast<const VkSubpassBeginInfo *>( &subpassBeginInfo ),
-                            reinterpret_cast<const VkSubpassEndInfo *>( &subpassEndInfo ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    CommandBuffer::pipelineBarrier( VULKAN_HPP_NAMESPACE::PipelineStageFlags          srcStageMask,
-                                    VULKAN_HPP_NAMESPACE::PipelineStageFlags          dstStageMask,
-                                    VULKAN_HPP_NAMESPACE::DependencyFlags             dependencyFlags,
-                                    uint32_t                                          memoryBarrierCount,
-                                    const VULKAN_HPP_NAMESPACE::MemoryBarrier *       pMemoryBarriers,
-                                    uint32_t                                          bufferMemoryBarrierCount,
-                                    const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier * pBufferMemoryBarriers,
-                                    uint32_t                                          imageMemoryBarrierCount,
-                                    const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier *  pImageMemoryBarriers,
-                                    Dispatch const &                                  d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdPipelineBarrier( m_commandBuffer,
-                            static_cast<VkPipelineStageFlags>( srcStageMask ),
-                            static_cast<VkPipelineStageFlags>( dstStageMask ),
-                            static_cast<VkDependencyFlags>( dependencyFlags ),
-                            memoryBarrierCount,
-                            reinterpret_cast<const VkMemoryBarrier *>( pMemoryBarriers ),
-                            bufferMemoryBarrierCount,
-                            reinterpret_cast<const VkBufferMemoryBarrier *>( pBufferMemoryBarriers ),
-                            imageMemoryBarrierCount,
-                            reinterpret_cast<const VkImageMemoryBarrier *>( pImageMemoryBarriers ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier(
-    VULKAN_HPP_NAMESPACE::PipelineStageFlags                            srcStageMask,
-    VULKAN_HPP_NAMESPACE::PipelineStageFlags                            dstStageMask,
-    VULKAN_HPP_NAMESPACE::DependencyFlags                               dependencyFlags,
-    ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const &       memoryBarriers,
-    ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const & bufferMemoryBarriers,
-    ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const &  imageMemoryBarriers,
-    Dispatch const &                                                    d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdPipelineBarrier( m_commandBuffer,
-                            static_cast<VkPipelineStageFlags>( srcStageMask ),
-                            static_cast<VkPipelineStageFlags>( dstStageMask ),
-                            static_cast<VkDependencyFlags>( dependencyFlags ),
-                            memoryBarriers.size(),
-                            reinterpret_cast<const VkMemoryBarrier *>( memoryBarriers.data() ),
-                            bufferMemoryBarriers.size(),
-                            reinterpret_cast<const VkBufferMemoryBarrier *>( bufferMemoryBarriers.data() ),
-                            imageMemoryBarriers.size(),
-                            reinterpret_cast<const VkImageMemoryBarrier *>( imageMemoryBarriers.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    CommandBuffer::pipelineBarrier2KHR( const VULKAN_HPP_NAMESPACE::DependencyInfoKHR * pDependencyInfo,
-                                        Dispatch const &                                d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdPipelineBarrier2KHR( m_commandBuffer, reinterpret_cast<const VkDependencyInfoKHR *>( pDependencyInfo ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier2KHR( const DependencyInfoKHR & dependencyInfo,
-                                                             Dispatch const &          d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdPipelineBarrier2KHR( m_commandBuffer, reinterpret_cast<const VkDependencyInfoKHR *>( &dependencyInfo ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::preprocessGeneratedCommandsNV(
-    const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV * pGeneratedCommandsInfo,
-    Dispatch const &                                      d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdPreprocessGeneratedCommandsNV(
-      m_commandBuffer, reinterpret_cast<const VkGeneratedCommandsInfoNV *>( pGeneratedCommandsInfo ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    CommandBuffer::preprocessGeneratedCommandsNV( const GeneratedCommandsInfoNV & generatedCommandsInfo,
-                                                  Dispatch const &                d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdPreprocessGeneratedCommandsNV(
-      m_commandBuffer, reinterpret_cast<const VkGeneratedCommandsInfoNV *>( &generatedCommandsInfo ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout   layout,
-                                                       VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags,
-                                                       uint32_t                               offset,
-                                                       uint32_t                               size,
-                                                       const void *                           pValues,
-                                                       Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdPushConstants( m_commandBuffer,
-                          static_cast<VkPipelineLayout>( layout ),
-                          static_cast<VkShaderStageFlags>( stageFlags ),
-                          offset,
-                          size,
-                          pValues );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename T, typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout   layout,
-                                                       VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags,
-                                                       uint32_t                               offset,
-                                                       ArrayProxy<const T> const &            values,
-                                                       Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdPushConstants( m_commandBuffer,
-                          static_cast<VkPipelineLayout>( layout ),
-                          static_cast<VkShaderStageFlags>( stageFlags ),
-                          offset,
-                          values.size() * sizeof( T ),
-                          reinterpret_cast<const void *>( values.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    CommandBuffer::pushDescriptorSetKHR( VULKAN_HPP_NAMESPACE::PipelineBindPoint          pipelineBindPoint,
-                                         VULKAN_HPP_NAMESPACE::PipelineLayout             layout,
-                                         uint32_t                                         set,
-                                         uint32_t                                         descriptorWriteCount,
-                                         const VULKAN_HPP_NAMESPACE::WriteDescriptorSet * pDescriptorWrites,
-                                         Dispatch const &                                 d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdPushDescriptorSetKHR( m_commandBuffer,
-                                 static_cast<VkPipelineBindPoint>( pipelineBindPoint ),
-                                 static_cast<VkPipelineLayout>( layout ),
-                                 set,
-                                 descriptorWriteCount,
-                                 reinterpret_cast<const VkWriteDescriptorSet *>( pDescriptorWrites ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetKHR(
-    VULKAN_HPP_NAMESPACE::PipelineBindPoint                            pipelineBindPoint,
-    VULKAN_HPP_NAMESPACE::PipelineLayout                               layout,
-    uint32_t                                                           set,
-    ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites,
-    Dispatch const &                                                   d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdPushDescriptorSetKHR( m_commandBuffer,
-                                 static_cast<VkPipelineBindPoint>( pipelineBindPoint ),
-                                 static_cast<VkPipelineLayout>( layout ),
-                                 set,
-                                 descriptorWrites.size(),
-                                 reinterpret_cast<const VkWriteDescriptorSet *>( descriptorWrites.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplateKHR(
-    VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
-    VULKAN_HPP_NAMESPACE::PipelineLayout           layout,
-    uint32_t                                       set,
-    const void *                                   pData,
-    Dispatch const &                               d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdPushDescriptorSetWithTemplateKHR( m_commandBuffer,
-                                             static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
-                                             static_cast<VkPipelineLayout>( layout ),
-                                             set,
-                                             pData );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::resetEvent( VULKAN_HPP_NAMESPACE::Event              event,
-                                                    VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask,
-                                                    Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdResetEvent( m_commandBuffer, static_cast<VkEvent>( event ), static_cast<VkPipelineStageFlags>( stageMask ) );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::resetEvent2KHR( VULKAN_HPP_NAMESPACE::Event                  event,
-                                                        VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR stageMask,
-                                                        Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdResetEvent2KHR(
-      m_commandBuffer, static_cast<VkEvent>( event ), static_cast<VkPipelineStageFlags2KHR>( stageMask ) );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::resetQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
-                                                        uint32_t                        firstQuery,
-                                                        uint32_t                        queryCount,
-                                                        Dispatch const &                d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdResetQueryPool( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::resolveImage( VULKAN_HPP_NAMESPACE::Image                srcImage,
-                                                      VULKAN_HPP_NAMESPACE::ImageLayout          srcImageLayout,
-                                                      VULKAN_HPP_NAMESPACE::Image                dstImage,
-                                                      VULKAN_HPP_NAMESPACE::ImageLayout          dstImageLayout,
-                                                      uint32_t                                   regionCount,
-                                                      const VULKAN_HPP_NAMESPACE::ImageResolve * pRegions,
-                                                      Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdResolveImage( m_commandBuffer,
-                         static_cast<VkImage>( srcImage ),
-                         static_cast<VkImageLayout>( srcImageLayout ),
-                         static_cast<VkImage>( dstImage ),
-                         static_cast<VkImageLayout>( dstImageLayout ),
-                         regionCount,
-                         reinterpret_cast<const VkImageResolve *>( pRegions ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    CommandBuffer::resolveImage( VULKAN_HPP_NAMESPACE::Image                                  srcImage,
-                                 VULKAN_HPP_NAMESPACE::ImageLayout                            srcImageLayout,
-                                 VULKAN_HPP_NAMESPACE::Image                                  dstImage,
-                                 VULKAN_HPP_NAMESPACE::ImageLayout                            dstImageLayout,
-                                 ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageResolve> const & regions,
-                                 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdResolveImage( m_commandBuffer,
-                         static_cast<VkImage>( srcImage ),
-                         static_cast<VkImageLayout>( srcImageLayout ),
-                         static_cast<VkImage>( dstImage ),
-                         static_cast<VkImageLayout>( dstImageLayout ),
-                         regions.size(),
-                         reinterpret_cast<const VkImageResolve *>( regions.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    CommandBuffer::resolveImage2KHR( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2KHR * pResolveImageInfo,
-                                     Dispatch const &                                   d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdResolveImage2KHR( m_commandBuffer, reinterpret_cast<const VkResolveImageInfo2KHR *>( pResolveImageInfo ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::resolveImage2KHR( const ResolveImageInfo2KHR & resolveImageInfo,
-                                                          Dispatch const &             d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdResolveImage2KHR( m_commandBuffer, reinterpret_cast<const VkResolveImageInfo2KHR *>( &resolveImageInfo ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setBlendConstants( const float      blendConstants[4],
-                                                           Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdSetBlendConstants( m_commandBuffer, blendConstants );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setCheckpointNV( const void *     pCheckpointMarker,
-                                                         Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdSetCheckpointNV( m_commandBuffer, pCheckpointMarker );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    CommandBuffer::setCoarseSampleOrderNV( VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV sampleOrderType,
-                                           uint32_t                                      customSampleOrderCount,
-                                           const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV * pCustomSampleOrders,
-                                           Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdSetCoarseSampleOrderNV( m_commandBuffer,
-                                   static_cast<VkCoarseSampleOrderTypeNV>( sampleOrderType ),
-                                   customSampleOrderCount,
-                                   reinterpret_cast<const VkCoarseSampleOrderCustomNV *>( pCustomSampleOrders ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setCoarseSampleOrderNV(
-    VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV                             sampleOrderType,
-    ArrayProxy<const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV> const & customSampleOrders,
-    Dispatch const &                                                          d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdSetCoarseSampleOrderNV( m_commandBuffer,
-                                   static_cast<VkCoarseSampleOrderTypeNV>( sampleOrderType ),
-                                   customSampleOrders.size(),
-                                   reinterpret_cast<const VkCoarseSampleOrderCustomNV *>( customSampleOrders.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setColorWriteEnableEXT( uint32_t                             attachmentCount,
-                                                                const VULKAN_HPP_NAMESPACE::Bool32 * pColorWriteEnables,
-                                                                Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdSetColorWriteEnableEXT(
-      m_commandBuffer, attachmentCount, reinterpret_cast<const VkBool32 *>( pColorWriteEnables ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    CommandBuffer::setColorWriteEnableEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & colorWriteEnables,
-                                           Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdSetColorWriteEnableEXT(
-      m_commandBuffer, colorWriteEnables.size(), reinterpret_cast<const VkBool32 *>( colorWriteEnables.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setCullModeEXT( VULKAN_HPP_NAMESPACE::CullModeFlags cullMode,
-                                                        Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdSetCullModeEXT( m_commandBuffer, static_cast<VkCullModeFlags>( cullMode ) );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setDepthBias( float            depthBiasConstantFactor,
-                                                      float            depthBiasClamp,
-                                                      float            depthBiasSlopeFactor,
-                                                      Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdSetDepthBias( m_commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setDepthBiasEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable,
-                                                               Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdSetDepthBiasEnableEXT( m_commandBuffer, static_cast<VkBool32>( depthBiasEnable ) );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setDepthBounds( float            minDepthBounds,
-                                                        float            maxDepthBounds,
-                                                        Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdSetDepthBounds( m_commandBuffer, minDepthBounds, maxDepthBounds );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setDepthBoundsTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable,
-                                                                     Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdSetDepthBoundsTestEnableEXT( m_commandBuffer, static_cast<VkBool32>( depthBoundsTestEnable ) );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setDepthCompareOpEXT( VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp,
-                                                              Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdSetDepthCompareOpEXT( m_commandBuffer, static_cast<VkCompareOp>( depthCompareOp ) );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setDepthTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable,
-                                                               Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdSetDepthTestEnableEXT( m_commandBuffer, static_cast<VkBool32>( depthTestEnable ) );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setDepthWriteEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable,
-                                                                Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdSetDepthWriteEnableEXT( m_commandBuffer, static_cast<VkBool32>( depthWriteEnable ) );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setDeviceMask( uint32_t         deviceMask,
-                                                       Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdSetDeviceMask( m_commandBuffer, deviceMask );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setDeviceMaskKHR( uint32_t         deviceMask,
-                                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdSetDeviceMaskKHR( m_commandBuffer, deviceMask );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleEXT( uint32_t firstDiscardRectangle,
-                                                                uint32_t discardRectangleCount,
-                                                                const VULKAN_HPP_NAMESPACE::Rect2D * pDiscardRectangles,
-                                                                Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdSetDiscardRectangleEXT( m_commandBuffer,
-                                   firstDiscardRectangle,
-                                   discardRectangleCount,
-                                   reinterpret_cast<const VkRect2D *>( pDiscardRectangles ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    CommandBuffer::setDiscardRectangleEXT( uint32_t                                               firstDiscardRectangle,
-                                           ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & discardRectangles,
-                                           Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdSetDiscardRectangleEXT( m_commandBuffer,
-                                   firstDiscardRectangle,
-                                   discardRectangles.size(),
-                                   reinterpret_cast<const VkRect2D *>( discardRectangles.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setEvent( VULKAN_HPP_NAMESPACE::Event              event,
-                                                  VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask,
-                                                  Dispatch const &                         d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdSetEvent( m_commandBuffer, static_cast<VkEvent>( event ), static_cast<VkPipelineStageFlags>( stageMask ) );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setEvent2KHR( VULKAN_HPP_NAMESPACE::Event                     event,
-                                                      const VULKAN_HPP_NAMESPACE::DependencyInfoKHR * pDependencyInfo,
-                                                      Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdSetEvent2KHR( m_commandBuffer,
-                         static_cast<VkEvent>( event ),
-                         reinterpret_cast<const VkDependencyInfoKHR *>( pDependencyInfo ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setEvent2KHR( VULKAN_HPP_NAMESPACE::Event event,
-                                                      const DependencyInfoKHR &   dependencyInfo,
-                                                      Dispatch const &            d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdSetEvent2KHR( m_commandBuffer,
-                         static_cast<VkEvent>( event ),
-                         reinterpret_cast<const VkDependencyInfoKHR *>( &dependencyInfo ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setExclusiveScissorNV( uint32_t firstExclusiveScissor,
-                                                               uint32_t exclusiveScissorCount,
-                                                               const VULKAN_HPP_NAMESPACE::Rect2D * pExclusiveScissors,
-                                                               Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdSetExclusiveScissorNV( m_commandBuffer,
-                                  firstExclusiveScissor,
-                                  exclusiveScissorCount,
-                                  reinterpret_cast<const VkRect2D *>( pExclusiveScissors ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    CommandBuffer::setExclusiveScissorNV( uint32_t                                               firstExclusiveScissor,
-                                          ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & exclusiveScissors,
-                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdSetExclusiveScissorNV( m_commandBuffer,
-                                  firstExclusiveScissor,
-                                  exclusiveScissors.size(),
-                                  reinterpret_cast<const VkRect2D *>( exclusiveScissors.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setFragmentShadingRateEnumNV(
-    VULKAN_HPP_NAMESPACE::FragmentShadingRateNV                  shadingRate,
-    const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2],
-    Dispatch const &                                             d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdSetFragmentShadingRateEnumNV( m_commandBuffer,
-                                         static_cast<VkFragmentShadingRateNV>( shadingRate ),
-                                         reinterpret_cast<const VkFragmentShadingRateCombinerOpKHR *>( combinerOps ) );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setFragmentShadingRateKHR(
-    const VULKAN_HPP_NAMESPACE::Extent2D *                       pFragmentSize,
-    const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2],
-    Dispatch const &                                             d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdSetFragmentShadingRateKHR( m_commandBuffer,
-                                      reinterpret_cast<const VkExtent2D *>( pFragmentSize ),
-                                      reinterpret_cast<const VkFragmentShadingRateCombinerOpKHR *>( combinerOps ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setFragmentShadingRateKHR(
-    const Extent2D &                                             fragmentSize,
-    const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2],
-    Dispatch const &                                             d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdSetFragmentShadingRateKHR( m_commandBuffer,
-                                      reinterpret_cast<const VkExtent2D *>( &fragmentSize ),
-                                      reinterpret_cast<const VkFragmentShadingRateCombinerOpKHR *>( combinerOps ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setFrontFaceEXT( VULKAN_HPP_NAMESPACE::FrontFace frontFace,
-                                                         Dispatch const &                d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdSetFrontFaceEXT( m_commandBuffer, static_cast<VkFrontFace>( frontFace ) );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setLineStippleEXT( uint32_t         lineStippleFactor,
-                                                           uint16_t         lineStipplePattern,
-                                                           Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdSetLineStippleEXT( m_commandBuffer, lineStippleFactor, lineStipplePattern );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setLineWidth( float lineWidth, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdSetLineWidth( m_commandBuffer, lineWidth );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setLogicOpEXT( VULKAN_HPP_NAMESPACE::LogicOp logicOp,
-                                                       Dispatch const &              d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdSetLogicOpEXT( m_commandBuffer, static_cast<VkLogicOp>( logicOp ) );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setPatchControlPointsEXT( uint32_t         patchControlPoints,
-                                                                  Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdSetPatchControlPointsEXT( m_commandBuffer, patchControlPoints );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result CommandBuffer::setPerformanceMarkerINTEL(
-    const VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL * pMarkerInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkCmdSetPerformanceMarkerINTEL(
-      m_commandBuffer, reinterpret_cast<const VkPerformanceMarkerInfoINTEL *>( pMarkerInfo ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
-    CommandBuffer::setPerformanceMarkerINTEL( const PerformanceMarkerInfoINTEL & markerInfo, Dispatch const & d ) const
-  {
-    Result result = static_cast<Result>( d.vkCmdSetPerformanceMarkerINTEL(
-      m_commandBuffer, reinterpret_cast<const VkPerformanceMarkerInfoINTEL *>( &markerInfo ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setPerformanceMarkerINTEL" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result CommandBuffer::setPerformanceOverrideINTEL(
-    const VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL * pOverrideInfo,
-    Dispatch const &                                           d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkCmdSetPerformanceOverrideINTEL(
-      m_commandBuffer, reinterpret_cast<const VkPerformanceOverrideInfoINTEL *>( pOverrideInfo ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
-    CommandBuffer::setPerformanceOverrideINTEL( const PerformanceOverrideInfoINTEL & overrideInfo,
-                                                Dispatch const &                     d ) const
-  {
-    Result result = static_cast<Result>( d.vkCmdSetPerformanceOverrideINTEL(
-      m_commandBuffer, reinterpret_cast<const VkPerformanceOverrideInfoINTEL *>( &overrideInfo ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setPerformanceOverrideINTEL" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result CommandBuffer::setPerformanceStreamMarkerINTEL(
-    const VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL * pMarkerInfo,
-    Dispatch const &                                               d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkCmdSetPerformanceStreamMarkerINTEL(
-      m_commandBuffer, reinterpret_cast<const VkPerformanceStreamMarkerInfoINTEL *>( pMarkerInfo ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
-    CommandBuffer::setPerformanceStreamMarkerINTEL( const PerformanceStreamMarkerInfoINTEL & markerInfo,
-                                                    Dispatch const &                         d ) const
-  {
-    Result result = static_cast<Result>( d.vkCmdSetPerformanceStreamMarkerINTEL(
-      m_commandBuffer, reinterpret_cast<const VkPerformanceStreamMarkerInfoINTEL *>( &markerInfo ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setPerformanceStreamMarkerINTEL" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    CommandBuffer::setPrimitiveRestartEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable,
-                                                 Dispatch const &             d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdSetPrimitiveRestartEnableEXT( m_commandBuffer, static_cast<VkBool32>( primitiveRestartEnable ) );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    CommandBuffer::setPrimitiveTopologyEXT( VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology,
-                                            Dispatch const &                        d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdSetPrimitiveTopologyEXT( m_commandBuffer, static_cast<VkPrimitiveTopology>( primitiveTopology ) );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    CommandBuffer::setRasterizerDiscardEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable,
-                                                  Dispatch const &             d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdSetRasterizerDiscardEnableEXT( m_commandBuffer, static_cast<VkBool32>( rasterizerDiscardEnable ) );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    CommandBuffer::setRayTracingPipelineStackSizeKHR( uint32_t         pipelineStackSize,
-                                                      Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdSetRayTracingPipelineStackSizeKHR( m_commandBuffer, pipelineStackSize );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    CommandBuffer::setSampleLocationsEXT( const VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT * pSampleLocationsInfo,
-                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdSetSampleLocationsEXT( m_commandBuffer,
-                                  reinterpret_cast<const VkSampleLocationsInfoEXT *>( pSampleLocationsInfo ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setSampleLocationsEXT( const SampleLocationsInfoEXT & sampleLocationsInfo,
-                                                               Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdSetSampleLocationsEXT( m_commandBuffer,
-                                  reinterpret_cast<const VkSampleLocationsInfoEXT *>( &sampleLocationsInfo ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setScissor( uint32_t                             firstScissor,
-                                                    uint32_t                             scissorCount,
-                                                    const VULKAN_HPP_NAMESPACE::Rect2D * pScissors,
-                                                    Dispatch const &                     d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdSetScissor( m_commandBuffer, firstScissor, scissorCount, reinterpret_cast<const VkRect2D *>( pScissors ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setScissor( uint32_t                                               firstScissor,
-                                                    ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors,
-                                                    Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdSetScissor(
-      m_commandBuffer, firstScissor, scissors.size(), reinterpret_cast<const VkRect2D *>( scissors.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setScissorWithCountEXT( uint32_t                             scissorCount,
-                                                                const VULKAN_HPP_NAMESPACE::Rect2D * pScissors,
-                                                                Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdSetScissorWithCountEXT( m_commandBuffer, scissorCount, reinterpret_cast<const VkRect2D *>( pScissors ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    CommandBuffer::setScissorWithCountEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors,
-                                           Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdSetScissorWithCountEXT(
-      m_commandBuffer, scissors.size(), reinterpret_cast<const VkRect2D *>( scissors.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setStencilCompareMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
-                                                               uint32_t                               compareMask,
-                                                               Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdSetStencilCompareMask( m_commandBuffer, static_cast<VkStencilFaceFlags>( faceMask ), compareMask );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setStencilOpEXT( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
-                                                         VULKAN_HPP_NAMESPACE::StencilOp        failOp,
-                                                         VULKAN_HPP_NAMESPACE::StencilOp        passOp,
-                                                         VULKAN_HPP_NAMESPACE::StencilOp        depthFailOp,
-                                                         VULKAN_HPP_NAMESPACE::CompareOp        compareOp,
-                                                         Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdSetStencilOpEXT( m_commandBuffer,
-                            static_cast<VkStencilFaceFlags>( faceMask ),
-                            static_cast<VkStencilOp>( failOp ),
-                            static_cast<VkStencilOp>( passOp ),
-                            static_cast<VkStencilOp>( depthFailOp ),
-                            static_cast<VkCompareOp>( compareOp ) );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setStencilReference( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
-                                                             uint32_t                               reference,
-                                                             Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdSetStencilReference( m_commandBuffer, static_cast<VkStencilFaceFlags>( faceMask ), reference );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setStencilTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable,
-                                                                 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdSetStencilTestEnableEXT( m_commandBuffer, static_cast<VkBool32>( stencilTestEnable ) );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setStencilWriteMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
-                                                             uint32_t                               writeMask,
-                                                             Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdSetStencilWriteMask( m_commandBuffer, static_cast<VkStencilFaceFlags>( faceMask ), writeMask );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setVertexInputEXT(
-    uint32_t                                                          vertexBindingDescriptionCount,
-    const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT *   pVertexBindingDescriptions,
-    uint32_t                                                          vertexAttributeDescriptionCount,
-    const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT * pVertexAttributeDescriptions,
-    Dispatch const &                                                  d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdSetVertexInputEXT(
-      m_commandBuffer,
-      vertexBindingDescriptionCount,
-      reinterpret_cast<const VkVertexInputBindingDescription2EXT *>( pVertexBindingDescriptions ),
-      vertexAttributeDescriptionCount,
-      reinterpret_cast<const VkVertexInputAttributeDescription2EXT *>( pVertexAttributeDescriptions ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setVertexInputEXT(
-    ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT> const &   vertexBindingDescriptions,
-    ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT> const & vertexAttributeDescriptions,
-    Dispatch const &                                                                    d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdSetVertexInputEXT(
-      m_commandBuffer,
-      vertexBindingDescriptions.size(),
-      reinterpret_cast<const VkVertexInputBindingDescription2EXT *>( vertexBindingDescriptions.data() ),
-      vertexAttributeDescriptions.size(),
-      reinterpret_cast<const VkVertexInputAttributeDescription2EXT *>( vertexAttributeDescriptions.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setViewport( uint32_t                               firstViewport,
-                                                     uint32_t                               viewportCount,
-                                                     const VULKAN_HPP_NAMESPACE::Viewport * pViewports,
-                                                     Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdSetViewport(
-      m_commandBuffer, firstViewport, viewportCount, reinterpret_cast<const VkViewport *>( pViewports ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setViewport( uint32_t firstViewport,
-                                                     ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports,
-                                                     Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdSetViewport(
-      m_commandBuffer, firstViewport, viewports.size(), reinterpret_cast<const VkViewport *>( viewports.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setViewportShadingRatePaletteNV(
-    uint32_t                                           firstViewport,
-    uint32_t                                           viewportCount,
-    const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV * pShadingRatePalettes,
-    Dispatch const &                                   d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdSetViewportShadingRatePaletteNV( m_commandBuffer,
-                                            firstViewport,
-                                            viewportCount,
-                                            reinterpret_cast<const VkShadingRatePaletteNV *>( pShadingRatePalettes ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setViewportShadingRatePaletteNV(
-    uint32_t                                                             firstViewport,
-    ArrayProxy<const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV> const & shadingRatePalettes,
-    Dispatch const &                                                     d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdSetViewportShadingRatePaletteNV(
-      m_commandBuffer,
-      firstViewport,
-      shadingRatePalettes.size(),
-      reinterpret_cast<const VkShadingRatePaletteNV *>( shadingRatePalettes.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    CommandBuffer::setViewportWScalingNV( uint32_t                                         firstViewport,
-                                          uint32_t                                         viewportCount,
-                                          const VULKAN_HPP_NAMESPACE::ViewportWScalingNV * pViewportWScalings,
-                                          Dispatch const &                                 d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdSetViewportWScalingNV( m_commandBuffer,
-                                  firstViewport,
-                                  viewportCount,
-                                  reinterpret_cast<const VkViewportWScalingNV *>( pViewportWScalings ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setViewportWScalingNV(
-    uint32_t                                                           firstViewport,
-    ArrayProxy<const VULKAN_HPP_NAMESPACE::ViewportWScalingNV> const & viewportWScalings,
-    Dispatch const &                                                   d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdSetViewportWScalingNV( m_commandBuffer,
-                                  firstViewport,
-                                  viewportWScalings.size(),
-                                  reinterpret_cast<const VkViewportWScalingNV *>( viewportWScalings.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setViewportWithCountEXT( uint32_t                               viewportCount,
-                                                                 const VULKAN_HPP_NAMESPACE::Viewport * pViewports,
-                                                                 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdSetViewportWithCountEXT(
-      m_commandBuffer, viewportCount, reinterpret_cast<const VkViewport *>( pViewports ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    CommandBuffer::setViewportWithCountEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports,
-                                            Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdSetViewportWithCountEXT(
-      m_commandBuffer, viewports.size(), reinterpret_cast<const VkViewport *>( viewports.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::traceRaysIndirectKHR(
-    const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pRaygenShaderBindingTable,
-    const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pMissShaderBindingTable,
-    const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pHitShaderBindingTable,
-    const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pCallableShaderBindingTable,
-    VULKAN_HPP_NAMESPACE::DeviceAddress                         indirectDeviceAddress,
-    Dispatch const &                                            d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdTraceRaysIndirectKHR(
-      m_commandBuffer,
-      reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( pRaygenShaderBindingTable ),
-      reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( pMissShaderBindingTable ),
-      reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( pHitShaderBindingTable ),
-      reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( pCallableShaderBindingTable ),
-      static_cast<VkDeviceAddress>( indirectDeviceAddress ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    CommandBuffer::traceRaysIndirectKHR( const StridedDeviceAddressRegionKHR & raygenShaderBindingTable,
-                                         const StridedDeviceAddressRegionKHR & missShaderBindingTable,
-                                         const StridedDeviceAddressRegionKHR & hitShaderBindingTable,
-                                         const StridedDeviceAddressRegionKHR & callableShaderBindingTable,
-                                         VULKAN_HPP_NAMESPACE::DeviceAddress   indirectDeviceAddress,
-                                         Dispatch const &                      d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdTraceRaysIndirectKHR(
-      m_commandBuffer,
-      reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &raygenShaderBindingTable ),
-      reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &missShaderBindingTable ),
-      reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &hitShaderBindingTable ),
-      reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &callableShaderBindingTable ),
-      static_cast<VkDeviceAddress>( indirectDeviceAddress ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::traceRaysKHR(
-    const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pRaygenShaderBindingTable,
-    const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pMissShaderBindingTable,
-    const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pHitShaderBindingTable,
-    const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pCallableShaderBindingTable,
-    uint32_t                                                    width,
-    uint32_t                                                    height,
-    uint32_t                                                    depth,
-    Dispatch const &                                            d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdTraceRaysKHR( m_commandBuffer,
-                         reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( pRaygenShaderBindingTable ),
-                         reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( pMissShaderBindingTable ),
-                         reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( pHitShaderBindingTable ),
-                         reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( pCallableShaderBindingTable ),
-                         width,
-                         height,
-                         depth );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::traceRaysKHR( const StridedDeviceAddressRegionKHR & raygenShaderBindingTable,
-                                                      const StridedDeviceAddressRegionKHR & missShaderBindingTable,
-                                                      const StridedDeviceAddressRegionKHR & hitShaderBindingTable,
-                                                      const StridedDeviceAddressRegionKHR & callableShaderBindingTable,
-                                                      uint32_t                              width,
-                                                      uint32_t                              height,
-                                                      uint32_t                              depth,
-                                                      Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdTraceRaysKHR( m_commandBuffer,
-                         reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &raygenShaderBindingTable ),
-                         reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &missShaderBindingTable ),
-                         reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &hitShaderBindingTable ),
-                         reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &callableShaderBindingTable ),
-                         width,
-                         height,
-                         depth );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::traceRaysNV( VULKAN_HPP_NAMESPACE::Buffer     raygenShaderBindingTableBuffer,
-                                                     VULKAN_HPP_NAMESPACE::DeviceSize raygenShaderBindingOffset,
-                                                     VULKAN_HPP_NAMESPACE::Buffer     missShaderBindingTableBuffer,
-                                                     VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingOffset,
-                                                     VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingStride,
-                                                     VULKAN_HPP_NAMESPACE::Buffer     hitShaderBindingTableBuffer,
-                                                     VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingOffset,
-                                                     VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingStride,
-                                                     VULKAN_HPP_NAMESPACE::Buffer     callableShaderBindingTableBuffer,
-                                                     VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingOffset,
-                                                     VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingStride,
-                                                     uint32_t                         width,
-                                                     uint32_t                         height,
-                                                     uint32_t                         depth,
-                                                     Dispatch const &                 d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdTraceRaysNV( m_commandBuffer,
-                        static_cast<VkBuffer>( raygenShaderBindingTableBuffer ),
-                        static_cast<VkDeviceSize>( raygenShaderBindingOffset ),
-                        static_cast<VkBuffer>( missShaderBindingTableBuffer ),
-                        static_cast<VkDeviceSize>( missShaderBindingOffset ),
-                        static_cast<VkDeviceSize>( missShaderBindingStride ),
-                        static_cast<VkBuffer>( hitShaderBindingTableBuffer ),
-                        static_cast<VkDeviceSize>( hitShaderBindingOffset ),
-                        static_cast<VkDeviceSize>( hitShaderBindingStride ),
-                        static_cast<VkBuffer>( callableShaderBindingTableBuffer ),
-                        static_cast<VkDeviceSize>( callableShaderBindingOffset ),
-                        static_cast<VkDeviceSize>( callableShaderBindingStride ),
-                        width,
-                        height,
-                        depth );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::updateBuffer( VULKAN_HPP_NAMESPACE::Buffer     dstBuffer,
-                                                      VULKAN_HPP_NAMESPACE::DeviceSize dstOffset,
-                                                      VULKAN_HPP_NAMESPACE::DeviceSize dataSize,
-                                                      const void *                     pData,
-                                                      Dispatch const &                 d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdUpdateBuffer( m_commandBuffer,
-                         static_cast<VkBuffer>( dstBuffer ),
-                         static_cast<VkDeviceSize>( dstOffset ),
-                         static_cast<VkDeviceSize>( dataSize ),
-                         pData );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename T, typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::updateBuffer( VULKAN_HPP_NAMESPACE::Buffer     dstBuffer,
-                                                      VULKAN_HPP_NAMESPACE::DeviceSize dstOffset,
-                                                      ArrayProxy<const T> const &      data,
-                                                      Dispatch const &                 d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdUpdateBuffer( m_commandBuffer,
-                         static_cast<VkBuffer>( dstBuffer ),
-                         static_cast<VkDeviceSize>( dstOffset ),
-                         data.size() * sizeof( T ),
-                         reinterpret_cast<const void *>( data.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    CommandBuffer::waitEvents( uint32_t                                          eventCount,
-                               const VULKAN_HPP_NAMESPACE::Event *               pEvents,
-                               VULKAN_HPP_NAMESPACE::PipelineStageFlags          srcStageMask,
-                               VULKAN_HPP_NAMESPACE::PipelineStageFlags          dstStageMask,
-                               uint32_t                                          memoryBarrierCount,
-                               const VULKAN_HPP_NAMESPACE::MemoryBarrier *       pMemoryBarriers,
-                               uint32_t                                          bufferMemoryBarrierCount,
-                               const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier * pBufferMemoryBarriers,
-                               uint32_t                                          imageMemoryBarrierCount,
-                               const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier *  pImageMemoryBarriers,
-                               Dispatch const &                                  d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdWaitEvents( m_commandBuffer,
-                       eventCount,
-                       reinterpret_cast<const VkEvent *>( pEvents ),
-                       static_cast<VkPipelineStageFlags>( srcStageMask ),
-                       static_cast<VkPipelineStageFlags>( dstStageMask ),
-                       memoryBarrierCount,
-                       reinterpret_cast<const VkMemoryBarrier *>( pMemoryBarriers ),
-                       bufferMemoryBarrierCount,
-                       reinterpret_cast<const VkBufferMemoryBarrier *>( pBufferMemoryBarriers ),
-                       imageMemoryBarrierCount,
-                       reinterpret_cast<const VkImageMemoryBarrier *>( pImageMemoryBarriers ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    CommandBuffer::waitEvents( ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const &               events,
-                               VULKAN_HPP_NAMESPACE::PipelineStageFlags                            srcStageMask,
-                               VULKAN_HPP_NAMESPACE::PipelineStageFlags                            dstStageMask,
-                               ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const &       memoryBarriers,
-                               ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const & bufferMemoryBarriers,
-                               ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const &  imageMemoryBarriers,
-                               Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdWaitEvents( m_commandBuffer,
-                       events.size(),
-                       reinterpret_cast<const VkEvent *>( events.data() ),
-                       static_cast<VkPipelineStageFlags>( srcStageMask ),
-                       static_cast<VkPipelineStageFlags>( dstStageMask ),
-                       memoryBarriers.size(),
-                       reinterpret_cast<const VkMemoryBarrier *>( memoryBarriers.data() ),
-                       bufferMemoryBarriers.size(),
-                       reinterpret_cast<const VkBufferMemoryBarrier *>( bufferMemoryBarriers.data() ),
-                       imageMemoryBarriers.size(),
-                       reinterpret_cast<const VkImageMemoryBarrier *>( imageMemoryBarriers.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    CommandBuffer::waitEvents2KHR( uint32_t                                        eventCount,
-                                   const VULKAN_HPP_NAMESPACE::Event *             pEvents,
-                                   const VULKAN_HPP_NAMESPACE::DependencyInfoKHR * pDependencyInfos,
-                                   Dispatch const &                                d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdWaitEvents2KHR( m_commandBuffer,
-                           eventCount,
-                           reinterpret_cast<const VkEvent *>( pEvents ),
-                           reinterpret_cast<const VkDependencyInfoKHR *>( pDependencyInfos ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    CommandBuffer::waitEvents2KHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const &             events,
-                                   ArrayProxy<const VULKAN_HPP_NAMESPACE::DependencyInfoKHR> const & dependencyInfos,
-                                   Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
-  {
-#  ifdef VULKAN_HPP_NO_EXCEPTIONS
-    VULKAN_HPP_ASSERT( events.size() == dependencyInfos.size() );
-#  else
-    if ( events.size() != dependencyInfos.size() )
-    {
-      throw LogicError( VULKAN_HPP_NAMESPACE_STRING
-                        "::CommandBuffer::waitEvents2KHR: events.size() != dependencyInfos.size()" );
-    }
-#  endif /*VULKAN_HPP_NO_EXCEPTIONS*/
-
-    d.vkCmdWaitEvents2KHR( m_commandBuffer,
-                           events.size(),
-                           reinterpret_cast<const VkEvent *>( events.data() ),
-                           reinterpret_cast<const VkDependencyInfoKHR *>( dependencyInfos.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesKHR(
-    uint32_t                                               accelerationStructureCount,
-    const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR * pAccelerationStructures,
-    VULKAN_HPP_NAMESPACE::QueryType                        queryType,
-    VULKAN_HPP_NAMESPACE::QueryPool                        queryPool,
-    uint32_t                                               firstQuery,
-    Dispatch const &                                       d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdWriteAccelerationStructuresPropertiesKHR(
-      m_commandBuffer,
-      accelerationStructureCount,
-      reinterpret_cast<const VkAccelerationStructureKHR *>( pAccelerationStructures ),
-      static_cast<VkQueryType>( queryType ),
-      static_cast<VkQueryPool>( queryPool ),
-      firstQuery );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesKHR(
-    ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
-    VULKAN_HPP_NAMESPACE::QueryType                                          queryType,
-    VULKAN_HPP_NAMESPACE::QueryPool                                          queryPool,
-    uint32_t                                                                 firstQuery,
-    Dispatch const &                                                         d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdWriteAccelerationStructuresPropertiesKHR(
-      m_commandBuffer,
-      accelerationStructures.size(),
-      reinterpret_cast<const VkAccelerationStructureKHR *>( accelerationStructures.data() ),
-      static_cast<VkQueryType>( queryType ),
-      static_cast<VkQueryPool>( queryPool ),
-      firstQuery );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesNV(
-    uint32_t                                              accelerationStructureCount,
-    const VULKAN_HPP_NAMESPACE::AccelerationStructureNV * pAccelerationStructures,
-    VULKAN_HPP_NAMESPACE::QueryType                       queryType,
-    VULKAN_HPP_NAMESPACE::QueryPool                       queryPool,
-    uint32_t                                              firstQuery,
-    Dispatch const &                                      d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdWriteAccelerationStructuresPropertiesNV(
-      m_commandBuffer,
-      accelerationStructureCount,
-      reinterpret_cast<const VkAccelerationStructureNV *>( pAccelerationStructures ),
-      static_cast<VkQueryType>( queryType ),
-      static_cast<VkQueryPool>( queryPool ),
-      firstQuery );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesNV(
-    ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureNV> const & accelerationStructures,
-    VULKAN_HPP_NAMESPACE::QueryType                                         queryType,
-    VULKAN_HPP_NAMESPACE::QueryPool                                         queryPool,
-    uint32_t                                                                firstQuery,
-    Dispatch const &                                                        d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdWriteAccelerationStructuresPropertiesNV(
-      m_commandBuffer,
-      accelerationStructures.size(),
-      reinterpret_cast<const VkAccelerationStructureNV *>( accelerationStructures.data() ),
-      static_cast<VkQueryType>( queryType ),
-      static_cast<VkQueryPool>( queryPool ),
-      firstQuery );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::writeBufferMarker2AMD( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR stage,
-                                                               VULKAN_HPP_NAMESPACE::Buffer                 dstBuffer,
-                                                               VULKAN_HPP_NAMESPACE::DeviceSize             dstOffset,
-                                                               uint32_t                                     marker,
-                                                               Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdWriteBufferMarker2AMD( m_commandBuffer,
-                                  static_cast<VkPipelineStageFlags2KHR>( stage ),
-                                  static_cast<VkBuffer>( dstBuffer ),
-                                  static_cast<VkDeviceSize>( dstOffset ),
-                                  marker );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::writeBufferMarkerAMD( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage,
-                                                              VULKAN_HPP_NAMESPACE::Buffer                dstBuffer,
-                                                              VULKAN_HPP_NAMESPACE::DeviceSize            dstOffset,
-                                                              uint32_t                                    marker,
-                                                              Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdWriteBufferMarkerAMD( m_commandBuffer,
-                                 static_cast<VkPipelineStageFlagBits>( pipelineStage ),
-                                 static_cast<VkBuffer>( dstBuffer ),
-                                 static_cast<VkDeviceSize>( dstOffset ),
-                                 marker );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::writeTimestamp( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage,
-                                                        VULKAN_HPP_NAMESPACE::QueryPool             queryPool,
-                                                        uint32_t                                    query,
-                                                        Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdWriteTimestamp( m_commandBuffer,
-                           static_cast<VkPipelineStageFlagBits>( pipelineStage ),
-                           static_cast<VkQueryPool>( queryPool ),
-                           query );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::writeTimestamp2KHR( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR stage,
-                                                            VULKAN_HPP_NAMESPACE::QueryPool              queryPool,
-                                                            uint32_t                                     query,
-                                                            Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkCmdWriteTimestamp2KHR(
-      m_commandBuffer, static_cast<VkPipelineStageFlags2KHR>( stage ), static_cast<VkQueryPool>( queryPool ), query );
-  }
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result CommandBuffer::end( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkEndCommandBuffer( m_commandBuffer ) );
-  }
-#else
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
-    CommandBuffer::end( Dispatch const & d ) const
-  {
-    Result result = static_cast<Result>( d.vkEndCommandBuffer( m_commandBuffer ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::end" );
+    Queue::submit( ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo> const & submits,
+                   VULKAN_HPP_NAMESPACE::Fence                                fence,
+                   Dispatch const &                                           d ) const
+  {
+    Result result = static_cast<Result>( d.vkQueueSubmit( m_queue,
+                                                          submits.size(),
+                                                          reinterpret_cast<const VkSubmitInfo *>( submits.data() ),
+                                                          static_cast<VkFence>( fence ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::submit" );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result CommandBuffer::reset(
-    VULKAN_HPP_NAMESPACE::CommandBufferResetFlags flags, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Queue::waitIdle( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
-    return static_cast<Result>(
-      d.vkResetCommandBuffer( m_commandBuffer, static_cast<VkCommandBufferResetFlags>( flags ) ) );
+    return static_cast<Result>( d.vkQueueWaitIdle( m_queue ) );
   }
 #else
   template <typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<void>::type
-    CommandBuffer::reset( VULKAN_HPP_NAMESPACE::CommandBufferResetFlags flags, Dispatch const & d ) const
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
+    Queue::waitIdle( Dispatch const & d ) const
   {
-    Result result =
-      static_cast<Result>( d.vkResetCommandBuffer( m_commandBuffer, static_cast<VkCommandBufferResetFlags>( flags ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::reset" );
+    Result result = static_cast<Result>( d.vkQueueWaitIdle( m_queue ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::waitIdle" );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
-#if defined( VK_USE_PLATFORM_WIN32_KHR )
-#  ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::acquireFullScreenExclusiveModeEXT(
-    VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::waitIdle( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
-    return static_cast<Result>(
-      d.vkAcquireFullScreenExclusiveModeEXT( m_device, static_cast<VkSwapchainKHR>( swapchain ) ) );
+    return static_cast<Result>( d.vkDeviceWaitIdle( m_device ) );
   }
-#  else
+#else
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
-    Device::acquireFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d ) const
+    Device::waitIdle( Dispatch const & d ) const
   {
-    Result result = static_cast<Result>(
-      d.vkAcquireFullScreenExclusiveModeEXT( m_device, static_cast<VkSwapchainKHR>( swapchain ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::acquireFullScreenExclusiveModeEXT" );
-  }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_USE_PLATFORM_WIN32_KHR*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::acquireNextImage2KHR( const VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR * pAcquireInfo,
-                                  uint32_t *                                            pImageIndex,
-                                  Dispatch const &                                      d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkAcquireNextImage2KHR(
-      m_device, reinterpret_cast<const VkAcquireNextImageInfoKHR *>( pAcquireInfo ), pImageIndex ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<uint32_t>
-    Device::acquireNextImage2KHR( const AcquireNextImageInfoKHR & acquireInfo, Dispatch const & d ) const
-  {
-    uint32_t imageIndex;
-    Result   result = static_cast<Result>( d.vkAcquireNextImage2KHR(
-      m_device, reinterpret_cast<const VkAcquireNextImageInfoKHR *>( &acquireInfo ), &imageIndex ) );
-    return createResultValue( result,
-                              imageIndex,
-                              VULKAN_HPP_NAMESPACE_STRING "::Device::acquireNextImage2KHR",
-                              { VULKAN_HPP_NAMESPACE::Result::eSuccess,
-                                VULKAN_HPP_NAMESPACE::Result::eTimeout,
-                                VULKAN_HPP_NAMESPACE::Result::eNotReady,
-                                VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR } );
+    Result result = static_cast<Result>( d.vkDeviceWaitIdle( m_device ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::waitIdle" );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::acquireNextImageKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
-                                 uint64_t                           timeout,
-                                 VULKAN_HPP_NAMESPACE::Semaphore    semaphore,
-                                 VULKAN_HPP_NAMESPACE::Fence        fence,
-                                 uint32_t *                         pImageIndex,
-                                 Dispatch const &                   d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkAcquireNextImageKHR( m_device,
-                                                         static_cast<VkSwapchainKHR>( swapchain ),
-                                                         timeout,
-                                                         static_cast<VkSemaphore>( semaphore ),
-                                                         static_cast<VkFence>( fence ),
-                                                         pImageIndex ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<uint32_t>
-                                         Device::acquireNextImageKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
-                                 uint64_t                           timeout,
-                                 VULKAN_HPP_NAMESPACE::Semaphore    semaphore,
-                                 VULKAN_HPP_NAMESPACE::Fence        fence,
-                                 Dispatch const &                   d ) const
-  {
-    uint32_t imageIndex;
-    Result   result = static_cast<Result>( d.vkAcquireNextImageKHR( m_device,
-                                                                  static_cast<VkSwapchainKHR>( swapchain ),
-                                                                  timeout,
-                                                                  static_cast<VkSemaphore>( semaphore ),
-                                                                  static_cast<VkFence>( fence ),
-                                                                  &imageIndex ) );
-    return createResultValue( result,
-                              imageIndex,
-                              VULKAN_HPP_NAMESPACE_STRING "::Device::acquireNextImageKHR",
-                              { VULKAN_HPP_NAMESPACE::Result::eSuccess,
-                                VULKAN_HPP_NAMESPACE::Result::eTimeout,
-                                VULKAN_HPP_NAMESPACE::Result::eNotReady,
-                                VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR } );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::acquirePerformanceConfigurationINTEL(
-    const VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL * pAcquireInfo,
-    VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL *                  pConfiguration,
-    Dispatch const &                                                       d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkAcquirePerformanceConfigurationINTEL(
-      m_device,
-      reinterpret_cast<const VkPerformanceConfigurationAcquireInfoINTEL *>( pAcquireInfo ),
-      reinterpret_cast<VkPerformanceConfigurationINTEL *>( pConfiguration ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL>::type
-    Device::acquirePerformanceConfigurationINTEL( const PerformanceConfigurationAcquireInfoINTEL & acquireInfo,
-                                                  Dispatch const &                                 d ) const
-  {
-    VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration;
-    Result result = static_cast<Result>( d.vkAcquirePerformanceConfigurationINTEL(
-      m_device,
-      reinterpret_cast<const VkPerformanceConfigurationAcquireInfoINTEL *>( &acquireInfo ),
-      reinterpret_cast<VkPerformanceConfigurationINTEL *>( &configuration ) ) );
-    return createResultValue(
-      result, configuration, VULKAN_HPP_NAMESPACE_STRING "::Device::acquirePerformanceConfigurationINTEL" );
-  }
-
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL, Dispatch>>::type
-    Device::acquirePerformanceConfigurationINTELUnique( const PerformanceConfigurationAcquireInfoINTEL & acquireInfo,
-                                                        Dispatch const &                                 d ) const
-  {
-    VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration;
-    Result                          result = static_cast<Result>( d.vkAcquirePerformanceConfigurationINTEL(
-      m_device,
-      reinterpret_cast<const VkPerformanceConfigurationAcquireInfoINTEL *>( &acquireInfo ),
-      reinterpret_cast<VkPerformanceConfigurationINTEL *>( &configuration ) ) );
-    ObjectRelease<Device, Dispatch> deleter( *this, d );
-    return createResultValue<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL, Dispatch>(
-      result,
-      configuration,
-      VULKAN_HPP_NAMESPACE_STRING "::Device::acquirePerformanceConfigurationINTELUnique",
-      deleter );
-  }
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::acquireProfilingLockKHR(
-    const VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR * pInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkAcquireProfilingLockKHR( m_device, reinterpret_cast<const VkAcquireProfilingLockInfoKHR *>( pInfo ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
-    Device::acquireProfilingLockKHR( const AcquireProfilingLockInfoKHR & info, Dispatch const & d ) const
-  {
-    Result result = static_cast<Result>(
-      d.vkAcquireProfilingLockKHR( m_device, reinterpret_cast<const VkAcquireProfilingLockInfoKHR *>( &info ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::acquireProfilingLockKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::allocateCommandBuffers( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo * pAllocateInfo,
-                                    VULKAN_HPP_NAMESPACE::CommandBuffer *                   pCommandBuffers,
-                                    Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkAllocateCommandBuffers( m_device,
-                                  reinterpret_cast<const VkCommandBufferAllocateInfo *>( pAllocateInfo ),
-                                  reinterpret_cast<VkCommandBuffer *>( pCommandBuffers ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename CommandBufferAllocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<std::vector<CommandBuffer, CommandBufferAllocator>>::type
-    Device::allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo, Dispatch const & d ) const
-  {
-    std::vector<CommandBuffer, CommandBufferAllocator> commandBuffers( allocateInfo.commandBufferCount );
-    Result                                             result = static_cast<Result>(
-      d.vkAllocateCommandBuffers( m_device,
-                                  reinterpret_cast<const VkCommandBufferAllocateInfo *>( &allocateInfo ),
-                                  reinterpret_cast<VkCommandBuffer *>( commandBuffers.data() ) ) );
-    return createResultValue( result, commandBuffers, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffers" );
-  }
-
-  template <typename CommandBufferAllocator,
-            typename Dispatch,
-            typename B,
-            typename std::enable_if<std::is_same<typename B::value_type, CommandBuffer>::value, int>::type>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<std::vector<CommandBuffer, CommandBufferAllocator>>::type
-    Device::allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo,
-                                    CommandBufferAllocator &          commandBufferAllocator,
-                                    Dispatch const &                  d ) const
-  {
-    std::vector<CommandBuffer, CommandBufferAllocator> commandBuffers( allocateInfo.commandBufferCount,
-                                                                       commandBufferAllocator );
-    Result                                             result = static_cast<Result>(
-      d.vkAllocateCommandBuffers( m_device,
-                                  reinterpret_cast<const VkCommandBufferAllocateInfo *>( &allocateInfo ),
-                                  reinterpret_cast<VkCommandBuffer *>( commandBuffers.data() ) ) );
-    return createResultValue( result, commandBuffers, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffers" );
-  }
-
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Dispatch, typename CommandBufferAllocator>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<std::vector<UniqueHandle<CommandBuffer, Dispatch>, CommandBufferAllocator>>::type
-    Device::allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo, Dispatch const & d ) const
-  {
-    std::vector<UniqueHandle<CommandBuffer, Dispatch>, CommandBufferAllocator> uniqueCommandBuffers;
-    std::vector<CommandBuffer> commandBuffers( allocateInfo.commandBufferCount );
-    Result                     result = static_cast<Result>(
-      d.vkAllocateCommandBuffers( m_device,
-                                  reinterpret_cast<const VkCommandBufferAllocateInfo *>( &allocateInfo ),
-                                  reinterpret_cast<VkCommandBuffer *>( commandBuffers.data() ) ) );
-    if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess )
-    {
-      uniqueCommandBuffers.reserve( allocateInfo.commandBufferCount );
-      PoolFree<Device, CommandPool, Dispatch> deleter( *this, allocateInfo.commandPool, d );
-      for ( size_t i = 0; i < allocateInfo.commandBufferCount; i++ )
-      {
-        uniqueCommandBuffers.push_back( UniqueHandle<CommandBuffer, Dispatch>( commandBuffers[i], deleter ) );
-      }
-    }
-    return createResultValue(
-      result, std::move( uniqueCommandBuffers ), VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffersUnique" );
-  }
-
-  template <typename Dispatch,
-            typename CommandBufferAllocator,
-            typename B,
-            typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<CommandBuffer, Dispatch>>::value,
-                                    int>::type>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<std::vector<UniqueHandle<CommandBuffer, Dispatch>, CommandBufferAllocator>>::type
-    Device::allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo,
-                                          CommandBufferAllocator &          commandBufferAllocator,
-                                          Dispatch const &                  d ) const
-  {
-    std::vector<UniqueHandle<CommandBuffer, Dispatch>, CommandBufferAllocator> uniqueCommandBuffers(
-      commandBufferAllocator );
-    std::vector<CommandBuffer> commandBuffers( allocateInfo.commandBufferCount );
-    Result                     result = static_cast<Result>(
-      d.vkAllocateCommandBuffers( m_device,
-                                  reinterpret_cast<const VkCommandBufferAllocateInfo *>( &allocateInfo ),
-                                  reinterpret_cast<VkCommandBuffer *>( commandBuffers.data() ) ) );
-    if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess )
-    {
-      uniqueCommandBuffers.reserve( allocateInfo.commandBufferCount );
-      PoolFree<Device, CommandPool, Dispatch> deleter( *this, allocateInfo.commandPool, d );
-      for ( size_t i = 0; i < allocateInfo.commandBufferCount; i++ )
-      {
-        uniqueCommandBuffers.push_back( UniqueHandle<CommandBuffer, Dispatch>( commandBuffers[i], deleter ) );
-      }
-    }
-    return createResultValue(
-      result, std::move( uniqueCommandBuffers ), VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffersUnique" );
-  }
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::allocateDescriptorSets( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo * pAllocateInfo,
-                                    VULKAN_HPP_NAMESPACE::DescriptorSet *                   pDescriptorSets,
-                                    Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkAllocateDescriptorSets( m_device,
-                                  reinterpret_cast<const VkDescriptorSetAllocateInfo *>( pAllocateInfo ),
-                                  reinterpret_cast<VkDescriptorSet *>( pDescriptorSets ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename DescriptorSetAllocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<std::vector<DescriptorSet, DescriptorSetAllocator>>::type
-    Device::allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo, Dispatch const & d ) const
-  {
-    std::vector<DescriptorSet, DescriptorSetAllocator> descriptorSets( allocateInfo.descriptorSetCount );
-    Result                                             result = static_cast<Result>(
-      d.vkAllocateDescriptorSets( m_device,
-                                  reinterpret_cast<const VkDescriptorSetAllocateInfo *>( &allocateInfo ),
-                                  reinterpret_cast<VkDescriptorSet *>( descriptorSets.data() ) ) );
-    return createResultValue( result, descriptorSets, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSets" );
-  }
-
-  template <typename DescriptorSetAllocator,
-            typename Dispatch,
-            typename B,
-            typename std::enable_if<std::is_same<typename B::value_type, DescriptorSet>::value, int>::type>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<std::vector<DescriptorSet, DescriptorSetAllocator>>::type
-    Device::allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo,
-                                    DescriptorSetAllocator &          descriptorSetAllocator,
-                                    Dispatch const &                  d ) const
-  {
-    std::vector<DescriptorSet, DescriptorSetAllocator> descriptorSets( allocateInfo.descriptorSetCount,
-                                                                       descriptorSetAllocator );
-    Result                                             result = static_cast<Result>(
-      d.vkAllocateDescriptorSets( m_device,
-                                  reinterpret_cast<const VkDescriptorSetAllocateInfo *>( &allocateInfo ),
-                                  reinterpret_cast<VkDescriptorSet *>( descriptorSets.data() ) ) );
-    return createResultValue( result, descriptorSets, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSets" );
-  }
-
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Dispatch, typename DescriptorSetAllocator>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<std::vector<UniqueHandle<DescriptorSet, Dispatch>, DescriptorSetAllocator>>::type
-    Device::allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo, Dispatch const & d ) const
-  {
-    std::vector<UniqueHandle<DescriptorSet, Dispatch>, DescriptorSetAllocator> uniqueDescriptorSets;
-    std::vector<DescriptorSet> descriptorSets( allocateInfo.descriptorSetCount );
-    Result                     result = static_cast<Result>(
-      d.vkAllocateDescriptorSets( m_device,
-                                  reinterpret_cast<const VkDescriptorSetAllocateInfo *>( &allocateInfo ),
-                                  reinterpret_cast<VkDescriptorSet *>( descriptorSets.data() ) ) );
-    if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess )
-    {
-      uniqueDescriptorSets.reserve( allocateInfo.descriptorSetCount );
-      PoolFree<Device, DescriptorPool, Dispatch> deleter( *this, allocateInfo.descriptorPool, d );
-      for ( size_t i = 0; i < allocateInfo.descriptorSetCount; i++ )
-      {
-        uniqueDescriptorSets.push_back( UniqueHandle<DescriptorSet, Dispatch>( descriptorSets[i], deleter ) );
-      }
-    }
-    return createResultValue(
-      result, std::move( uniqueDescriptorSets ), VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSetsUnique" );
-  }
-
-  template <typename Dispatch,
-            typename DescriptorSetAllocator,
-            typename B,
-            typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<DescriptorSet, Dispatch>>::value,
-                                    int>::type>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<std::vector<UniqueHandle<DescriptorSet, Dispatch>, DescriptorSetAllocator>>::type
-    Device::allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo,
-                                          DescriptorSetAllocator &          descriptorSetAllocator,
-                                          Dispatch const &                  d ) const
-  {
-    std::vector<UniqueHandle<DescriptorSet, Dispatch>, DescriptorSetAllocator> uniqueDescriptorSets(
-      descriptorSetAllocator );
-    std::vector<DescriptorSet> descriptorSets( allocateInfo.descriptorSetCount );
-    Result                     result = static_cast<Result>(
-      d.vkAllocateDescriptorSets( m_device,
-                                  reinterpret_cast<const VkDescriptorSetAllocateInfo *>( &allocateInfo ),
-                                  reinterpret_cast<VkDescriptorSet *>( descriptorSets.data() ) ) );
-    if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess )
-    {
-      uniqueDescriptorSets.reserve( allocateInfo.descriptorSetCount );
-      PoolFree<Device, DescriptorPool, Dispatch> deleter( *this, allocateInfo.descriptorPool, d );
-      for ( size_t i = 0; i < allocateInfo.descriptorSetCount; i++ )
-      {
-        uniqueDescriptorSets.push_back( UniqueHandle<DescriptorSet, Dispatch>( descriptorSets[i], deleter ) );
-      }
-    }
-    return createResultValue(
-      result, std::move( uniqueDescriptorSets ), VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSetsUnique" );
-  }
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
     Device::allocateMemory( const VULKAN_HPP_NAMESPACE::MemoryAllocateInfo *  pAllocateInfo,
@@ -105315,27 +102823,155 @@ namespace VULKAN_HPP_NAMESPACE
 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::bindAccelerationStructureMemoryNV(
-    uint32_t                                                            bindInfoCount,
-    const VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV * pBindInfos,
-    Dispatch const &                                                    d ) const VULKAN_HPP_NOEXCEPT
+  VULKAN_HPP_INLINE void Device::freeMemory( VULKAN_HPP_NAMESPACE::DeviceMemory                memory,
+                                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                             Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
-    return static_cast<Result>( d.vkBindAccelerationStructureMemoryNV(
-      m_device, bindInfoCount, reinterpret_cast<const VkBindAccelerationStructureMemoryInfoNV *>( pBindInfos ) ) );
+    d.vkFreeMemory(
+      m_device, static_cast<VkDeviceMemory>( memory ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::freeMemory( VULKAN_HPP_NAMESPACE::DeviceMemory  memory,
+                                             Optional<const AllocationCallbacks> allocator,
+                                             Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkFreeMemory( m_device,
+                    static_cast<VkDeviceMemory>( memory ),
+                    reinterpret_cast<const VkAllocationCallbacks *>(
+                      static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::free( VULKAN_HPP_NAMESPACE::DeviceMemory                memory,
+                                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                       Dispatch const &                                  d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkFreeMemory(
+      m_device, static_cast<VkDeviceMemory>( memory ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::free( VULKAN_HPP_NAMESPACE::DeviceMemory  memory,
+                                       Optional<const AllocationCallbacks> allocator,
+                                       Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkFreeMemory( m_device,
+                    static_cast<VkDeviceMemory>( memory ),
+                    reinterpret_cast<const VkAllocationCallbacks *>(
+                      static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::mapMemory( VULKAN_HPP_NAMESPACE::DeviceMemory   memory,
+                                                                   VULKAN_HPP_NAMESPACE::DeviceSize     offset,
+                                                                   VULKAN_HPP_NAMESPACE::DeviceSize     size,
+                                                                   VULKAN_HPP_NAMESPACE::MemoryMapFlags flags,
+                                                                   void **                              ppData,
+                                                                   Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkMapMemory( m_device,
+                                               static_cast<VkDeviceMemory>( memory ),
+                                               static_cast<VkDeviceSize>( offset ),
+                                               static_cast<VkDeviceSize>( size ),
+                                               static_cast<VkMemoryMapFlags>( flags ),
+                                               ppData ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void *>::type
+                                          Device::mapMemory( VULKAN_HPP_NAMESPACE::DeviceMemory   memory,
+                       VULKAN_HPP_NAMESPACE::DeviceSize     offset,
+                       VULKAN_HPP_NAMESPACE::DeviceSize     size,
+                       VULKAN_HPP_NAMESPACE::MemoryMapFlags flags,
+                       Dispatch const &                     d ) const
+  {
+    void * pData;
+    Result result = static_cast<Result>( d.vkMapMemory( m_device,
+                                                        static_cast<VkDeviceMemory>( memory ),
+                                                        static_cast<VkDeviceSize>( offset ),
+                                                        static_cast<VkDeviceSize>( size ),
+                                                        static_cast<VkMemoryMapFlags>( flags ),
+                                                        &pData ) );
+    return createResultValue( result, pData, VULKAN_HPP_NAMESPACE_STRING "::Device::mapMemory" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::unmapMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory,
+                                              Dispatch const &                   d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkUnmapMemory( m_device, static_cast<VkDeviceMemory>( memory ) );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::flushMappedMemoryRanges( uint32_t                                        memoryRangeCount,
+                                     const VULKAN_HPP_NAMESPACE::MappedMemoryRange * pMemoryRanges,
+                                     Dispatch const &                                d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkFlushMappedMemoryRanges(
+      m_device, memoryRangeCount, reinterpret_cast<const VkMappedMemoryRange *>( pMemoryRanges ) ) );
   }
 
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
-                                          Device::bindAccelerationStructureMemoryNV(
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV> const & bindInfos,
-      Dispatch const &                                                                      d ) const
+    Device::flushMappedMemoryRanges( ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges,
+                                     Dispatch const &                                                  d ) const
   {
-    Result result = static_cast<Result>( d.vkBindAccelerationStructureMemoryNV(
-      m_device,
-      bindInfos.size(),
-      reinterpret_cast<const VkBindAccelerationStructureMemoryInfoNV *>( bindInfos.data() ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindAccelerationStructureMemoryNV" );
+    Result result = static_cast<Result>( d.vkFlushMappedMemoryRanges(
+      m_device, memoryRanges.size(), reinterpret_cast<const VkMappedMemoryRange *>( memoryRanges.data() ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::flushMappedMemoryRanges" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::invalidateMappedMemoryRanges( uint32_t                                        memoryRangeCount,
+                                          const VULKAN_HPP_NAMESPACE::MappedMemoryRange * pMemoryRanges,
+                                          Dispatch const &                                d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkInvalidateMappedMemoryRanges(
+      m_device, memoryRangeCount, reinterpret_cast<const VkMappedMemoryRange *>( pMemoryRanges ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
+                                          Device::invalidateMappedMemoryRanges(
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges, Dispatch const & d ) const
+  {
+    Result result = static_cast<Result>( d.vkInvalidateMappedMemoryRanges(
+      m_device, memoryRanges.size(), reinterpret_cast<const VkMappedMemoryRange *>( memoryRanges.data() ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::invalidateMappedMemoryRanges" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::getMemoryCommitment( VULKAN_HPP_NAMESPACE::DeviceMemory memory,
+                                                      VULKAN_HPP_NAMESPACE::DeviceSize * pCommittedMemoryInBytes,
+                                                      Dispatch const &                   d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkGetDeviceMemoryCommitment(
+      m_device, static_cast<VkDeviceMemory>( memory ), reinterpret_cast<VkDeviceSize *>( pCommittedMemoryInBytes ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceSize
+                                         Device::getMemoryCommitment( VULKAN_HPP_NAMESPACE::DeviceMemory memory,
+                                 Dispatch const &                   d ) const VULKAN_HPP_NOEXCEPT
+  {
+    VULKAN_HPP_NAMESPACE::DeviceSize committedMemoryInBytes;
+    d.vkGetDeviceMemoryCommitment(
+      m_device, static_cast<VkDeviceMemory>( memory ), reinterpret_cast<VkDeviceSize *>( &committedMemoryInBytes ) );
+    return committedMemoryInBytes;
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -105367,50 +103003,6 @@ namespace VULKAN_HPP_NAMESPACE
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::bindBufferMemory2( uint32_t                                           bindInfoCount,
-                               const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo * pBindInfos,
-                               Dispatch const &                                   d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkBindBufferMemory2(
-      m_device, bindInfoCount, reinterpret_cast<const VkBindBufferMemoryInfo *>( pBindInfos ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
-    Device::bindBufferMemory2( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos,
-                               Dispatch const &                                                     d ) const
-  {
-    Result result = static_cast<Result>( d.vkBindBufferMemory2(
-      m_device, bindInfos.size(), reinterpret_cast<const VkBindBufferMemoryInfo *>( bindInfos.data() ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindBufferMemory2" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::bindBufferMemory2KHR( uint32_t                                           bindInfoCount,
-                                  const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo * pBindInfos,
-                                  Dispatch const &                                   d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkBindBufferMemory2KHR(
-      m_device, bindInfoCount, reinterpret_cast<const VkBindBufferMemoryInfo *>( pBindInfos ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
-    Device::bindBufferMemory2KHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos,
-                                  Dispatch const &                                                     d ) const
-  {
-    Result result = static_cast<Result>( d.vkBindBufferMemory2KHR(
-      m_device, bindInfos.size(), reinterpret_cast<const VkBindBufferMemoryInfo *>( bindInfos.data() ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindBufferMemory2KHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::bindImageMemory( VULKAN_HPP_NAMESPACE::Image        image,
@@ -105440,355 +103032,841 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::bindImageMemory2( uint32_t                                          bindInfoCount,
-                              const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo * pBindInfos,
-                              Dispatch const &                                  d ) const VULKAN_HPP_NOEXCEPT
+  VULKAN_HPP_INLINE void
+    Device::getBufferMemoryRequirements( VULKAN_HPP_NAMESPACE::Buffer               buffer,
+                                         VULKAN_HPP_NAMESPACE::MemoryRequirements * pMemoryRequirements,
+                                         Dispatch const &                           d ) const VULKAN_HPP_NOEXCEPT
   {
-    return static_cast<Result>(
-      d.vkBindImageMemory2( m_device, bindInfoCount, reinterpret_cast<const VkBindImageMemoryInfo *>( pBindInfos ) ) );
+    d.vkGetBufferMemoryRequirements(
+      m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<VkMemoryRequirements *>( pMemoryRequirements ) );
   }
 
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
-    Device::bindImageMemory2( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos,
-                              Dispatch const &                                                    d ) const
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements
+                                         Device::getBufferMemoryRequirements( VULKAN_HPP_NAMESPACE::Buffer buffer,
+                                         Dispatch const &             d ) const VULKAN_HPP_NOEXCEPT
   {
-    Result result = static_cast<Result>( d.vkBindImageMemory2(
-      m_device, bindInfos.size(), reinterpret_cast<const VkBindImageMemoryInfo *>( bindInfos.data() ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindImageMemory2" );
+    VULKAN_HPP_NAMESPACE::MemoryRequirements memoryRequirements;
+    d.vkGetBufferMemoryRequirements(
+      m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<VkMemoryRequirements *>( &memoryRequirements ) );
+    return memoryRequirements;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    Device::getImageMemoryRequirements( VULKAN_HPP_NAMESPACE::Image                image,
+                                        VULKAN_HPP_NAMESPACE::MemoryRequirements * pMemoryRequirements,
+                                        Dispatch const &                           d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkGetImageMemoryRequirements(
+      m_device, static_cast<VkImage>( image ), reinterpret_cast<VkMemoryRequirements *>( pMemoryRequirements ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements
+                                         Device::getImageMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image,
+                                        Dispatch const &            d ) const VULKAN_HPP_NOEXCEPT
+  {
+    VULKAN_HPP_NAMESPACE::MemoryRequirements memoryRequirements;
+    d.vkGetImageMemoryRequirements(
+      m_device, static_cast<VkImage>( image ), reinterpret_cast<VkMemoryRequirements *>( &memoryRequirements ) );
+    return memoryRequirements;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements(
+    VULKAN_HPP_NAMESPACE::Image                           image,
+    uint32_t *                                            pSparseMemoryRequirementCount,
+    VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements * pSparseMemoryRequirements,
+    Dispatch const &                                      d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkGetImageSparseMemoryRequirements(
+      m_device,
+      static_cast<VkImage>( image ),
+      pSparseMemoryRequirementCount,
+      reinterpret_cast<VkSparseImageMemoryRequirements *>( pSparseMemoryRequirements ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename SparseImageMemoryRequirementsAllocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD
+    VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator>
+    Device::getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image, Dispatch const & d ) const
+  {
+    std::vector<SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator> sparseMemoryRequirements;
+    uint32_t                                                                           sparseMemoryRequirementCount;
+    d.vkGetImageSparseMemoryRequirements(
+      m_device, static_cast<VkImage>( image ), &sparseMemoryRequirementCount, nullptr );
+    sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
+    d.vkGetImageSparseMemoryRequirements(
+      m_device,
+      static_cast<VkImage>( image ),
+      &sparseMemoryRequirementCount,
+      reinterpret_cast<VkSparseImageMemoryRequirements *>( sparseMemoryRequirements.data() ) );
+    VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() );
+    return sparseMemoryRequirements;
+  }
+
+  template <
+    typename SparseImageMemoryRequirementsAllocator,
+    typename Dispatch,
+    typename B,
+    typename std::enable_if<std::is_same<typename B::value_type, SparseImageMemoryRequirements>::value, int>::type>
+  VULKAN_HPP_NODISCARD
+    VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator>
+                      Device::getImageSparseMemoryRequirements(
+      VULKAN_HPP_NAMESPACE::Image              image,
+      SparseImageMemoryRequirementsAllocator & sparseImageMemoryRequirementsAllocator,
+      Dispatch const &                         d ) const
+  {
+    std::vector<SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator> sparseMemoryRequirements(
+      sparseImageMemoryRequirementsAllocator );
+    uint32_t sparseMemoryRequirementCount;
+    d.vkGetImageSparseMemoryRequirements(
+      m_device, static_cast<VkImage>( image ), &sparseMemoryRequirementCount, nullptr );
+    sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
+    d.vkGetImageSparseMemoryRequirements(
+      m_device,
+      static_cast<VkImage>( image ),
+      &sparseMemoryRequirementCount,
+      reinterpret_cast<VkSparseImageMemoryRequirements *>( sparseMemoryRequirements.data() ) );
+    VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() );
+    return sparseMemoryRequirements;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    PhysicalDevice::getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format                        format,
+                                                    VULKAN_HPP_NAMESPACE::ImageType                     type,
+                                                    VULKAN_HPP_NAMESPACE::SampleCountFlagBits           samples,
+                                                    VULKAN_HPP_NAMESPACE::ImageUsageFlags               usage,
+                                                    VULKAN_HPP_NAMESPACE::ImageTiling                   tiling,
+                                                    uint32_t *                                          pPropertyCount,
+                                                    VULKAN_HPP_NAMESPACE::SparseImageFormatProperties * pProperties,
+                                                    Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkGetPhysicalDeviceSparseImageFormatProperties(
+      m_physicalDevice,
+      static_cast<VkFormat>( format ),
+      static_cast<VkImageType>( type ),
+      static_cast<VkSampleCountFlagBits>( samples ),
+      static_cast<VkImageUsageFlags>( usage ),
+      static_cast<VkImageTiling>( tiling ),
+      pPropertyCount,
+      reinterpret_cast<VkSparseImageFormatProperties *>( pProperties ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename SparseImageFormatPropertiesAllocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties, SparseImageFormatPropertiesAllocator>
+    PhysicalDevice::getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format              format,
+                                                    VULKAN_HPP_NAMESPACE::ImageType           type,
+                                                    VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,
+                                                    VULKAN_HPP_NAMESPACE::ImageUsageFlags     usage,
+                                                    VULKAN_HPP_NAMESPACE::ImageTiling         tiling,
+                                                    Dispatch const &                          d ) const
+  {
+    std::vector<SparseImageFormatProperties, SparseImageFormatPropertiesAllocator> properties;
+    uint32_t                                                                       propertyCount;
+    d.vkGetPhysicalDeviceSparseImageFormatProperties( m_physicalDevice,
+                                                      static_cast<VkFormat>( format ),
+                                                      static_cast<VkImageType>( type ),
+                                                      static_cast<VkSampleCountFlagBits>( samples ),
+                                                      static_cast<VkImageUsageFlags>( usage ),
+                                                      static_cast<VkImageTiling>( tiling ),
+                                                      &propertyCount,
+                                                      nullptr );
+    properties.resize( propertyCount );
+    d.vkGetPhysicalDeviceSparseImageFormatProperties(
+      m_physicalDevice,
+      static_cast<VkFormat>( format ),
+      static_cast<VkImageType>( type ),
+      static_cast<VkSampleCountFlagBits>( samples ),
+      static_cast<VkImageUsageFlags>( usage ),
+      static_cast<VkImageTiling>( tiling ),
+      &propertyCount,
+      reinterpret_cast<VkSparseImageFormatProperties *>( properties.data() ) );
+    VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+    return properties;
+  }
+
+  template <
+    typename SparseImageFormatPropertiesAllocator,
+    typename Dispatch,
+    typename B,
+    typename std::enable_if<std::is_same<typename B::value_type, SparseImageFormatProperties>::value, int>::type>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties, SparseImageFormatPropertiesAllocator>
+                                         PhysicalDevice::getSparseImageFormatProperties(
+      VULKAN_HPP_NAMESPACE::Format              format,
+      VULKAN_HPP_NAMESPACE::ImageType           type,
+      VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,
+      VULKAN_HPP_NAMESPACE::ImageUsageFlags     usage,
+      VULKAN_HPP_NAMESPACE::ImageTiling         tiling,
+      SparseImageFormatPropertiesAllocator &    sparseImageFormatPropertiesAllocator,
+      Dispatch const &                          d ) const
+  {
+    std::vector<SparseImageFormatProperties, SparseImageFormatPropertiesAllocator> properties(
+      sparseImageFormatPropertiesAllocator );
+    uint32_t propertyCount;
+    d.vkGetPhysicalDeviceSparseImageFormatProperties( m_physicalDevice,
+                                                      static_cast<VkFormat>( format ),
+                                                      static_cast<VkImageType>( type ),
+                                                      static_cast<VkSampleCountFlagBits>( samples ),
+                                                      static_cast<VkImageUsageFlags>( usage ),
+                                                      static_cast<VkImageTiling>( tiling ),
+                                                      &propertyCount,
+                                                      nullptr );
+    properties.resize( propertyCount );
+    d.vkGetPhysicalDeviceSparseImageFormatProperties(
+      m_physicalDevice,
+      static_cast<VkFormat>( format ),
+      static_cast<VkImageType>( type ),
+      static_cast<VkSampleCountFlagBits>( samples ),
+      static_cast<VkImageUsageFlags>( usage ),
+      static_cast<VkImageTiling>( tiling ),
+      &propertyCount,
+      reinterpret_cast<VkSparseImageFormatProperties *>( properties.data() ) );
+    VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+    return properties;
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::bindImageMemory2KHR( uint32_t                                          bindInfoCount,
-                                 const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo * pBindInfos,
-                                 Dispatch const &                                  d ) const VULKAN_HPP_NOEXCEPT
+    Queue::bindSparse( uint32_t                                     bindInfoCount,
+                       const VULKAN_HPP_NAMESPACE::BindSparseInfo * pBindInfo,
+                       VULKAN_HPP_NAMESPACE::Fence                  fence,
+                       Dispatch const &                             d ) const VULKAN_HPP_NOEXCEPT
   {
-    return static_cast<Result>( d.vkBindImageMemory2KHR(
-      m_device, bindInfoCount, reinterpret_cast<const VkBindImageMemoryInfo *>( pBindInfos ) ) );
+    return static_cast<Result>( d.vkQueueBindSparse( m_queue,
+                                                     bindInfoCount,
+                                                     reinterpret_cast<const VkBindSparseInfo *>( pBindInfo ),
+                                                     static_cast<VkFence>( fence ) ) );
   }
 
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
-    Device::bindImageMemory2KHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos,
-                                 Dispatch const &                                                    d ) const
+    Queue::bindSparse( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindSparseInfo> const & bindInfo,
+                       VULKAN_HPP_NAMESPACE::Fence                                    fence,
+                       Dispatch const &                                               d ) const
   {
-    Result result = static_cast<Result>( d.vkBindImageMemory2KHR(
-      m_device, bindInfos.size(), reinterpret_cast<const VkBindImageMemoryInfo *>( bindInfos.data() ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindImageMemory2KHR" );
+    Result result =
+      static_cast<Result>( d.vkQueueBindSparse( m_queue,
+                                                bindInfo.size(),
+                                                reinterpret_cast<const VkBindSparseInfo *>( bindInfo.data() ),
+                                                static_cast<VkFence>( fence ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::bindSparse" );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
-#if defined( VK_ENABLE_BETA_EXTENSIONS )
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::bindVideoSessionMemoryKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR            videoSession,
-                                       uint32_t                                         videoSessionBindMemoryCount,
-                                       const VULKAN_HPP_NAMESPACE::VideoBindMemoryKHR * pVideoSessionBindMemories,
-                                       Dispatch const &                                 d ) const VULKAN_HPP_NOEXCEPT
+    Device::createFence( const VULKAN_HPP_NAMESPACE::FenceCreateInfo *     pCreateInfo,
+                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                         VULKAN_HPP_NAMESPACE::Fence *                     pFence,
+                         Dispatch const &                                  d ) const VULKAN_HPP_NOEXCEPT
   {
-    return static_cast<Result>(
-      d.vkBindVideoSessionMemoryKHR( m_device,
-                                     static_cast<VkVideoSessionKHR>( videoSession ),
-                                     videoSessionBindMemoryCount,
-                                     reinterpret_cast<const VkVideoBindMemoryKHR *>( pVideoSessionBindMemories ) ) );
-  }
-
-#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
-                                          Device::bindVideoSessionMemoryKHR(
-      VULKAN_HPP_NAMESPACE::VideoSessionKHR                              videoSession,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::VideoBindMemoryKHR> const & videoSessionBindMemories,
-      Dispatch const &                                                   d ) const
-  {
-    Result result = static_cast<Result>( d.vkBindVideoSessionMemoryKHR(
-      m_device,
-      static_cast<VkVideoSessionKHR>( videoSession ),
-      videoSessionBindMemories.size(),
-      reinterpret_cast<const VkVideoBindMemoryKHR *>( videoSessionBindMemories.data() ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindVideoSessionMemoryKHR" );
-  }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_ENABLE_BETA_EXTENSIONS*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::buildAccelerationStructuresKHR(
-    VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                   deferredOperation,
-    uint32_t                                                                     infoCount,
-    const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR *      pInfos,
-    const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos,
-    Dispatch const &                                                             d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkBuildAccelerationStructuresKHR(
-      m_device,
-      static_cast<VkDeferredOperationKHR>( deferredOperation ),
-      infoCount,
-      reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( pInfos ),
-      reinterpret_cast<const VkAccelerationStructureBuildRangeInfoKHR * const *>( ppBuildRangeInfos ) ) );
+    return static_cast<Result>( d.vkCreateFence( m_device,
+                                                 reinterpret_cast<const VkFenceCreateInfo *>( pCreateInfo ),
+                                                 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
+                                                 reinterpret_cast<VkFence *>( pFence ) ) );
   }
 
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::buildAccelerationStructuresKHR(
-    VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                                     deferredOperation,
-    ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const &      infos,
-    ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos,
-    Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::Fence>::type
+                                          Device::createFence( const FenceCreateInfo &             createInfo,
+                         Optional<const AllocationCallbacks> allocator,
+                         Dispatch const &                    d ) const
   {
-#  ifdef VULKAN_HPP_NO_EXCEPTIONS
-    VULKAN_HPP_ASSERT( infos.size() == pBuildRangeInfos.size() );
-#  else
-    if ( infos.size() != pBuildRangeInfos.size() )
-    {
-      throw LogicError( VULKAN_HPP_NAMESPACE_STRING
-                        "::Device::buildAccelerationStructuresKHR: infos.size() != pBuildRangeInfos.size()" );
-    }
-#  endif /*VULKAN_HPP_NO_EXCEPTIONS*/
+    VULKAN_HPP_NAMESPACE::Fence fence;
+    Result                      result = static_cast<Result>(
+      d.vkCreateFence( m_device,
+                       reinterpret_cast<const VkFenceCreateInfo *>( &createInfo ),
+                       reinterpret_cast<const VkAllocationCallbacks *>(
+                         static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                       reinterpret_cast<VkFence *>( &fence ) ) );
+    return createResultValue( result, fence, VULKAN_HPP_NAMESPACE_STRING "::Device::createFence" );
+  }
 
-    Result result = static_cast<Result>( d.vkBuildAccelerationStructuresKHR(
-      m_device,
-      static_cast<VkDeferredOperationKHR>( deferredOperation ),
-      infos.size(),
-      reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( infos.data() ),
-      reinterpret_cast<const VkAccelerationStructureBuildRangeInfoKHR * const *>( pBuildRangeInfos.data() ) ) );
-    return createResultValue( result,
-                              VULKAN_HPP_NAMESPACE_STRING "::Device::buildAccelerationStructuresKHR",
-                              { VULKAN_HPP_NAMESPACE::Result::eSuccess,
-                                VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR,
-                                VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR } );
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>>::type
+    Device::createFenceUnique( const FenceCreateInfo &             createInfo,
+                               Optional<const AllocationCallbacks> allocator,
+                               Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::Fence fence;
+    Result                      result = static_cast<Result>(
+      d.vkCreateFence( m_device,
+                       reinterpret_cast<const VkFenceCreateInfo *>( &createInfo ),
+                       reinterpret_cast<const VkAllocationCallbacks *>(
+                         static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                       reinterpret_cast<VkFence *>( &fence ) ) );
+    ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
+    return createResultValue<VULKAN_HPP_NAMESPACE::Fence, Dispatch>(
+      result, fence, VULKAN_HPP_NAMESPACE_STRING "::Device::createFenceUnique", deleter );
+  }
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyFence( VULKAN_HPP_NAMESPACE::Fence                       fence,
+                                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                               Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyFence(
+      m_device, static_cast<VkFence>( fence ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyFence( VULKAN_HPP_NAMESPACE::Fence         fence,
+                                               Optional<const AllocationCallbacks> allocator,
+                                               Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyFence( m_device,
+                      static_cast<VkFence>( fence ),
+                      reinterpret_cast<const VkAllocationCallbacks *>(
+                        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Fence                       fence,
+                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyFence(
+      m_device, static_cast<VkFence>( fence ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Fence         fence,
+                                          Optional<const AllocationCallbacks> allocator,
+                                          Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyFence( m_device,
+                      static_cast<VkFence>( fence ),
+                      reinterpret_cast<const VkAllocationCallbacks *>(
+                        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::resetFences( uint32_t                            fenceCount,
+                                                                     const VULKAN_HPP_NAMESPACE::Fence * pFences,
+                                                                     Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkResetFences( m_device, fenceCount, reinterpret_cast<const VkFence *>( pFences ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<void>::type
+    Device::resetFences( ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences, Dispatch const & d ) const
+  {
+    Result result = static_cast<Result>(
+      d.vkResetFences( m_device, fences.size(), reinterpret_cast<const VkFence *>( fences.data() ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::resetFences" );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::compileDeferredNV(
-    VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t shader, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getFenceStatus( VULKAN_HPP_NAMESPACE::Fence fence,
+                                                                        Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
-    return static_cast<Result>( d.vkCompileDeferredNV( m_device, static_cast<VkPipeline>( pipeline ), shader ) );
+    return static_cast<Result>( d.vkGetFenceStatus( m_device, static_cast<VkFence>( fence ) ) );
+  }
+#else
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getFenceStatus( VULKAN_HPP_NAMESPACE::Fence fence,
+                                                                        Dispatch const & d ) const
+  {
+    Result result = static_cast<Result>( d.vkGetFenceStatus( m_device, static_cast<VkFence>( fence ) ) );
+    return createResultValue( result,
+                              VULKAN_HPP_NAMESPACE_STRING "::Device::getFenceStatus",
+                              { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eNotReady } );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::waitForFences( uint32_t                            fenceCount,
+                                                                       const VULKAN_HPP_NAMESPACE::Fence * pFences,
+                                                                       VULKAN_HPP_NAMESPACE::Bool32        waitAll,
+                                                                       uint64_t                            timeout,
+                                                                       Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkWaitForFences(
+      m_device, fenceCount, reinterpret_cast<const VkFence *>( pFences ), static_cast<VkBool32>( waitAll ), timeout ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::waitForFences( ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences,
+                           VULKAN_HPP_NAMESPACE::Bool32                          waitAll,
+                           uint64_t                                              timeout,
+                           Dispatch const &                                      d ) const
+  {
+    Result result = static_cast<Result>( d.vkWaitForFences( m_device,
+                                                            fences.size(),
+                                                            reinterpret_cast<const VkFence *>( fences.data() ),
+                                                            static_cast<VkBool32>( waitAll ),
+                                                            timeout ) );
+    return createResultValue( result,
+                              VULKAN_HPP_NAMESPACE_STRING "::Device::waitForFences",
+                              { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eTimeout } );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::createSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo * pCreateInfo,
+                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                             VULKAN_HPP_NAMESPACE::Semaphore *                 pSemaphore,
+                             Dispatch const &                                  d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkCreateSemaphore( m_device,
+                                                     reinterpret_cast<const VkSemaphoreCreateInfo *>( pCreateInfo ),
+                                                     reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
+                                                     reinterpret_cast<VkSemaphore *>( pSemaphore ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::Semaphore>::type
+    Device::createSemaphore( const SemaphoreCreateInfo &         createInfo,
+                             Optional<const AllocationCallbacks> allocator,
+                             Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::Semaphore semaphore;
+    Result                          result = static_cast<Result>(
+      d.vkCreateSemaphore( m_device,
+                           reinterpret_cast<const VkSemaphoreCreateInfo *>( &createInfo ),
+                           reinterpret_cast<const VkAllocationCallbacks *>(
+                             static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                           reinterpret_cast<VkSemaphore *>( &semaphore ) ) );
+    return createResultValue( result, semaphore, VULKAN_HPP_NAMESPACE_STRING "::Device::createSemaphore" );
+  }
+
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Semaphore, Dispatch>>::type
+    Device::createSemaphoreUnique( const SemaphoreCreateInfo &         createInfo,
+                                   Optional<const AllocationCallbacks> allocator,
+                                   Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::Semaphore semaphore;
+    Result                          result = static_cast<Result>(
+      d.vkCreateSemaphore( m_device,
+                           reinterpret_cast<const VkSemaphoreCreateInfo *>( &createInfo ),
+                           reinterpret_cast<const VkAllocationCallbacks *>(
+                             static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                           reinterpret_cast<VkSemaphore *>( &semaphore ) ) );
+    ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
+    return createResultValue<VULKAN_HPP_NAMESPACE::Semaphore, Dispatch>(
+      result, semaphore, VULKAN_HPP_NAMESPACE_STRING "::Device::createSemaphoreUnique", deleter );
+  }
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroySemaphore( VULKAN_HPP_NAMESPACE::Semaphore                   semaphore,
+                                                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                                   Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroySemaphore(
+      m_device, static_cast<VkSemaphore>( semaphore ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroySemaphore( VULKAN_HPP_NAMESPACE::Semaphore     semaphore,
+                                                   Optional<const AllocationCallbacks> allocator,
+                                                   Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroySemaphore( m_device,
+                          static_cast<VkSemaphore>( semaphore ),
+                          reinterpret_cast<const VkAllocationCallbacks *>(
+                            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Semaphore                   semaphore,
+                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroySemaphore(
+      m_device, static_cast<VkSemaphore>( semaphore ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Semaphore     semaphore,
+                                          Optional<const AllocationCallbacks> allocator,
+                                          Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroySemaphore( m_device,
+                          static_cast<VkSemaphore>( semaphore ),
+                          reinterpret_cast<const VkAllocationCallbacks *>(
+                            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::createEvent( const VULKAN_HPP_NAMESPACE::EventCreateInfo *     pCreateInfo,
+                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                         VULKAN_HPP_NAMESPACE::Event *                     pEvent,
+                         Dispatch const &                                  d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkCreateEvent( m_device,
+                                                 reinterpret_cast<const VkEventCreateInfo *>( pCreateInfo ),
+                                                 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
+                                                 reinterpret_cast<VkEvent *>( pEvent ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::Event>::type
+                                          Device::createEvent( const EventCreateInfo &             createInfo,
+                         Optional<const AllocationCallbacks> allocator,
+                         Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::Event event;
+    Result                      result = static_cast<Result>(
+      d.vkCreateEvent( m_device,
+                       reinterpret_cast<const VkEventCreateInfo *>( &createInfo ),
+                       reinterpret_cast<const VkAllocationCallbacks *>(
+                         static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                       reinterpret_cast<VkEvent *>( &event ) ) );
+    return createResultValue( result, event, VULKAN_HPP_NAMESPACE_STRING "::Device::createEvent" );
+  }
+
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Event, Dispatch>>::type
+    Device::createEventUnique( const EventCreateInfo &             createInfo,
+                               Optional<const AllocationCallbacks> allocator,
+                               Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::Event event;
+    Result                      result = static_cast<Result>(
+      d.vkCreateEvent( m_device,
+                       reinterpret_cast<const VkEventCreateInfo *>( &createInfo ),
+                       reinterpret_cast<const VkAllocationCallbacks *>(
+                         static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                       reinterpret_cast<VkEvent *>( &event ) ) );
+    ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
+    return createResultValue<VULKAN_HPP_NAMESPACE::Event, Dispatch>(
+      result, event, VULKAN_HPP_NAMESPACE_STRING "::Device::createEventUnique", deleter );
+  }
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyEvent( VULKAN_HPP_NAMESPACE::Event                       event,
+                                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                               Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyEvent(
+      m_device, static_cast<VkEvent>( event ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyEvent( VULKAN_HPP_NAMESPACE::Event         event,
+                                               Optional<const AllocationCallbacks> allocator,
+                                               Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyEvent( m_device,
+                      static_cast<VkEvent>( event ),
+                      reinterpret_cast<const VkAllocationCallbacks *>(
+                        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Event                       event,
+                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyEvent(
+      m_device, static_cast<VkEvent>( event ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Event         event,
+                                          Optional<const AllocationCallbacks> allocator,
+                                          Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyEvent( m_device,
+                      static_cast<VkEvent>( event ),
+                      reinterpret_cast<const VkAllocationCallbacks *>(
+                        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getEventStatus( VULKAN_HPP_NAMESPACE::Event event,
+                                                                        Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkGetEventStatus( m_device, static_cast<VkEvent>( event ) ) );
+  }
+#else
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getEventStatus( VULKAN_HPP_NAMESPACE::Event event,
+                                                                        Dispatch const & d ) const
+  {
+    Result result = static_cast<Result>( d.vkGetEventStatus( m_device, static_cast<VkEvent>( event ) ) );
+    return createResultValue( result,
+                              VULKAN_HPP_NAMESPACE_STRING "::Device::getEventStatus",
+                              { VULKAN_HPP_NAMESPACE::Result::eEventSet, VULKAN_HPP_NAMESPACE::Result::eEventReset } );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::setEvent( VULKAN_HPP_NAMESPACE::Event event,
+                                                                  Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkSetEvent( m_device, static_cast<VkEvent>( event ) ) );
   }
 #else
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
-    Device::compileDeferredNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t shader, Dispatch const & d ) const
+    Device::setEvent( VULKAN_HPP_NAMESPACE::Event event, Dispatch const & d ) const
   {
-    Result result =
-      static_cast<Result>( d.vkCompileDeferredNV( m_device, static_cast<VkPipeline>( pipeline ), shader ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::compileDeferredNV" );
+    Result result = static_cast<Result>( d.vkSetEvent( m_device, static_cast<VkEvent>( event ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setEvent" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::resetEvent( VULKAN_HPP_NAMESPACE::Event event,
+                                                                    Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkResetEvent( m_device, static_cast<VkEvent>( event ) ) );
+  }
+#else
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::resetEvent( VULKAN_HPP_NAMESPACE::Event event,
+                                                                             Dispatch const & d ) const
+  {
+    Result result = static_cast<Result>( d.vkResetEvent( m_device, static_cast<VkEvent>( event ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::resetEvent" );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::copyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
-                                          const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR * pInfo,
+    Device::createQueryPool( const VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo * pCreateInfo,
+                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                             VULKAN_HPP_NAMESPACE::QueryPool *                 pQueryPool,
+                             Dispatch const &                                  d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkCreateQueryPool( m_device,
+                                                     reinterpret_cast<const VkQueryPoolCreateInfo *>( pCreateInfo ),
+                                                     reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
+                                                     reinterpret_cast<VkQueryPool *>( pQueryPool ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::QueryPool>::type
+    Device::createQueryPool( const QueryPoolCreateInfo &         createInfo,
+                             Optional<const AllocationCallbacks> allocator,
+                             Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::QueryPool queryPool;
+    Result                          result = static_cast<Result>(
+      d.vkCreateQueryPool( m_device,
+                           reinterpret_cast<const VkQueryPoolCreateInfo *>( &createInfo ),
+                           reinterpret_cast<const VkAllocationCallbacks *>(
+                             static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                           reinterpret_cast<VkQueryPool *>( &queryPool ) ) );
+    return createResultValue( result, queryPool, VULKAN_HPP_NAMESPACE_STRING "::Device::createQueryPool" );
+  }
+
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::QueryPool, Dispatch>>::type
+    Device::createQueryPoolUnique( const QueryPoolCreateInfo &         createInfo,
+                                   Optional<const AllocationCallbacks> allocator,
+                                   Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::QueryPool queryPool;
+    Result                          result = static_cast<Result>(
+      d.vkCreateQueryPool( m_device,
+                           reinterpret_cast<const VkQueryPoolCreateInfo *>( &createInfo ),
+                           reinterpret_cast<const VkAllocationCallbacks *>(
+                             static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                           reinterpret_cast<VkQueryPool *>( &queryPool ) ) );
+    ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
+    return createResultValue<VULKAN_HPP_NAMESPACE::QueryPool, Dispatch>(
+      result, queryPool, VULKAN_HPP_NAMESPACE_STRING "::Device::createQueryPoolUnique", deleter );
+  }
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyQueryPool( VULKAN_HPP_NAMESPACE::QueryPool                   queryPool,
+                                                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                                   Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyQueryPool(
+      m_device, static_cast<VkQueryPool>( queryPool ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyQueryPool( VULKAN_HPP_NAMESPACE::QueryPool     queryPool,
+                                                   Optional<const AllocationCallbacks> allocator,
+                                                   Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyQueryPool( m_device,
+                          static_cast<VkQueryPool>( queryPool ),
+                          reinterpret_cast<const VkAllocationCallbacks *>(
+                            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::QueryPool                   queryPool,
+                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
                                           Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
-    return static_cast<Result>(
-      d.vkCopyAccelerationStructureKHR( m_device,
-                                        static_cast<VkDeferredOperationKHR>( deferredOperation ),
-                                        reinterpret_cast<const VkCopyAccelerationStructureInfoKHR *>( pInfo ) ) );
+    d.vkDestroyQueryPool(
+      m_device, static_cast<VkQueryPool>( queryPool ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
 
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::copyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
-                                          const CopyAccelerationStructureInfoKHR &   info,
-                                          Dispatch const &                           d ) const
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::QueryPool     queryPool,
+                                          Optional<const AllocationCallbacks> allocator,
+                                          Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
   {
-    Result result = static_cast<Result>(
-      d.vkCopyAccelerationStructureKHR( m_device,
-                                        static_cast<VkDeferredOperationKHR>( deferredOperation ),
-                                        reinterpret_cast<const VkCopyAccelerationStructureInfoKHR *>( &info ) ) );
-    return createResultValue( result,
-                              VULKAN_HPP_NAMESPACE_STRING "::Device::copyAccelerationStructureKHR",
-                              { VULKAN_HPP_NAMESPACE::Result::eSuccess,
-                                VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR,
-                                VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR } );
+    d.vkDestroyQueryPool( m_device,
+                          static_cast<VkQueryPool>( queryPool ),
+                          reinterpret_cast<const VkAllocationCallbacks *>(
+                            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyAccelerationStructureToMemoryKHR(
-    VULKAN_HPP_NAMESPACE::DeferredOperationKHR                             deferredOperation,
-    const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR * pInfo,
-    Dispatch const &                                                       d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkCopyAccelerationStructureToMemoryKHR(
-      m_device,
-      static_cast<VkDeferredOperationKHR>( deferredOperation ),
-      reinterpret_cast<const VkCopyAccelerationStructureToMemoryInfoKHR *>( pInfo ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::copyAccelerationStructureToMemoryKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR       deferredOperation,
-                                                  const CopyAccelerationStructureToMemoryInfoKHR & info,
-                                                  Dispatch const &                                 d ) const
+    Device::getQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool        queryPool,
+                                 uint32_t                               firstQuery,
+                                 uint32_t                               queryCount,
+                                 size_t                                 dataSize,
+                                 void *                                 pData,
+                                 VULKAN_HPP_NAMESPACE::DeviceSize       stride,
+                                 VULKAN_HPP_NAMESPACE::QueryResultFlags flags,
+                                 Dispatch const &                       d ) const VULKAN_HPP_NOEXCEPT
   {
-    Result result = static_cast<Result>( d.vkCopyAccelerationStructureToMemoryKHR(
-      m_device,
-      static_cast<VkDeferredOperationKHR>( deferredOperation ),
-      reinterpret_cast<const VkCopyAccelerationStructureToMemoryInfoKHR *>( &info ) ) );
-    return createResultValue( result,
-                              VULKAN_HPP_NAMESPACE_STRING "::Device::copyAccelerationStructureToMemoryKHR",
-                              { VULKAN_HPP_NAMESPACE::Result::eSuccess,
-                                VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR,
-                                VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR } );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyMemoryToAccelerationStructureKHR(
-    VULKAN_HPP_NAMESPACE::DeferredOperationKHR                             deferredOperation,
-    const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR * pInfo,
-    Dispatch const &                                                       d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkCopyMemoryToAccelerationStructureKHR(
-      m_device,
-      static_cast<VkDeferredOperationKHR>( deferredOperation ),
-      reinterpret_cast<const VkCopyMemoryToAccelerationStructureInfoKHR *>( pInfo ) ) );
+    return static_cast<Result>( d.vkGetQueryPoolResults( m_device,
+                                                         static_cast<VkQueryPool>( queryPool ),
+                                                         firstQuery,
+                                                         queryCount,
+                                                         dataSize,
+                                                         pData,
+                                                         static_cast<VkDeviceSize>( stride ),
+                                                         static_cast<VkQueryResultFlags>( flags ) ) );
   }
 
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::copyMemoryToAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR       deferredOperation,
-                                                  const CopyMemoryToAccelerationStructureInfoKHR & info,
-                                                  Dispatch const &                                 d ) const
+  template <typename T, typename Dispatch>
+  VULKAN_HPP_DEPRECATED( "This function is deprecated. Use one of the other flavours of it." )
+  VULKAN_HPP_NODISCARD
+    VULKAN_HPP_INLINE Result Device::getQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool        queryPool,
+                                                          uint32_t                               firstQuery,
+                                                          uint32_t                               queryCount,
+                                                          ArrayProxy<T> const &                  data,
+                                                          VULKAN_HPP_NAMESPACE::DeviceSize       stride,
+                                                          VULKAN_HPP_NAMESPACE::QueryResultFlags flags,
+                                                          Dispatch const &                       d ) const
   {
-    Result result = static_cast<Result>( d.vkCopyMemoryToAccelerationStructureKHR(
-      m_device,
-      static_cast<VkDeferredOperationKHR>( deferredOperation ),
-      reinterpret_cast<const VkCopyMemoryToAccelerationStructureInfoKHR *>( &info ) ) );
-    return createResultValue( result,
-                              VULKAN_HPP_NAMESPACE_STRING "::Device::copyMemoryToAccelerationStructureKHR",
-                              { VULKAN_HPP_NAMESPACE::Result::eSuccess,
-                                VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR,
-                                VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR } );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createAccelerationStructureKHR(
-    const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR * pCreateInfo,
-    const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                pAllocator,
-    VULKAN_HPP_NAMESPACE::AccelerationStructureKHR *                 pAccelerationStructure,
-    Dispatch const &                                                 d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkCreateAccelerationStructureKHR( m_device,
-                                          reinterpret_cast<const VkAccelerationStructureCreateInfoKHR *>( pCreateInfo ),
-                                          reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
-                                          reinterpret_cast<VkAccelerationStructureKHR *>( pAccelerationStructure ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR>::type
-    Device::createAccelerationStructureKHR( const AccelerationStructureCreateInfoKHR & createInfo,
-                                            Optional<const AllocationCallbacks>        allocator,
-                                            Dispatch const &                           d ) const
-  {
-    VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure;
-    Result                                         result = static_cast<Result>( d.vkCreateAccelerationStructureKHR(
-      m_device,
-      reinterpret_cast<const VkAccelerationStructureCreateInfoKHR *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>(
-        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkAccelerationStructureKHR *>( &accelerationStructure ) ) );
+    Result result = static_cast<Result>( d.vkGetQueryPoolResults( m_device,
+                                                                  static_cast<VkQueryPool>( queryPool ),
+                                                                  firstQuery,
+                                                                  queryCount,
+                                                                  data.size() * sizeof( T ),
+                                                                  reinterpret_cast<void *>( data.data() ),
+                                                                  static_cast<VkDeviceSize>( stride ),
+                                                                  static_cast<VkQueryResultFlags>( flags ) ) );
     return createResultValue(
-      result, accelerationStructure, VULKAN_HPP_NAMESPACE_STRING "::Device::createAccelerationStructureKHR" );
+      result, VULKAN_HPP_NAMESPACE_STRING "::Device::getQueryPoolResults", { Result::eSuccess, Result::eNotReady } );
   }
 
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR, Dispatch>>::type
-    Device::createAccelerationStructureKHRUnique( const AccelerationStructureCreateInfoKHR & createInfo,
-                                                  Optional<const AllocationCallbacks>        allocator,
-                                                  Dispatch const &                           d ) const
+  template <typename T, typename Allocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<T, Allocator>>
+                                         Device::getQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool        queryPool,
+                                 uint32_t                               firstQuery,
+                                 uint32_t                               queryCount,
+                                 size_t                                 dataSize,
+                                 VULKAN_HPP_NAMESPACE::DeviceSize       stride,
+                                 VULKAN_HPP_NAMESPACE::QueryResultFlags flags,
+                                 Dispatch const &                       d ) const
   {
-    VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure;
-    Result                                         result = static_cast<Result>( d.vkCreateAccelerationStructureKHR(
-      m_device,
-      reinterpret_cast<const VkAccelerationStructureCreateInfoKHR *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>(
-        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkAccelerationStructureKHR *>( &accelerationStructure ) ) );
-    ObjectDestroy<Device, Dispatch>                deleter( *this, allocator, d );
-    return createResultValue<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR, Dispatch>(
-      result,
-      accelerationStructure,
-      VULKAN_HPP_NAMESPACE_STRING "::Device::createAccelerationStructureKHRUnique",
-      deleter );
-  }
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::createAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV * pCreateInfo,
-                                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks *               pAllocator,
-                                           VULKAN_HPP_NAMESPACE::AccelerationStructureNV * pAccelerationStructure,
-                                           Dispatch const &                                d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkCreateAccelerationStructureNV( m_device,
-                                         reinterpret_cast<const VkAccelerationStructureCreateInfoNV *>( pCreateInfo ),
-                                         reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
-                                         reinterpret_cast<VkAccelerationStructureNV *>( pAccelerationStructure ) ) );
+    VULKAN_HPP_ASSERT( dataSize % sizeof( T ) == 0 );
+    std::vector<T, Allocator> data( dataSize / sizeof( T ) );
+    Result                    result = static_cast<Result>( d.vkGetQueryPoolResults( m_device,
+                                                                  static_cast<VkQueryPool>( queryPool ),
+                                                                  firstQuery,
+                                                                  queryCount,
+                                                                  data.size() * sizeof( T ),
+                                                                  reinterpret_cast<void *>( data.data() ),
+                                                                  static_cast<VkDeviceSize>( stride ),
+                                                                  static_cast<VkQueryResultFlags>( flags ) ) );
+    return createResultValue( result,
+                              data,
+                              VULKAN_HPP_NAMESPACE_STRING "::Device::getQueryPoolResults",
+                              { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eNotReady } );
   }
 
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::AccelerationStructureNV>::type
-    Device::createAccelerationStructureNV( const AccelerationStructureCreateInfoNV & createInfo,
-                                           Optional<const AllocationCallbacks>       allocator,
-                                           Dispatch const &                          d ) const
+  template <typename T, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<T>
+                                         Device::getQueryPoolResult( VULKAN_HPP_NAMESPACE::QueryPool        queryPool,
+                                uint32_t                               firstQuery,
+                                uint32_t                               queryCount,
+                                VULKAN_HPP_NAMESPACE::DeviceSize       stride,
+                                VULKAN_HPP_NAMESPACE::QueryResultFlags flags,
+                                Dispatch const &                       d ) const
   {
-    VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure;
-    Result                                        result = static_cast<Result>( d.vkCreateAccelerationStructureNV(
-      m_device,
-      reinterpret_cast<const VkAccelerationStructureCreateInfoNV *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>(
-        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkAccelerationStructureNV *>( &accelerationStructure ) ) );
-    return createResultValue(
-      result, accelerationStructure, VULKAN_HPP_NAMESPACE_STRING "::Device::createAccelerationStructureNV" );
+    T      data;
+    Result result = static_cast<Result>( d.vkGetQueryPoolResults( m_device,
+                                                                  static_cast<VkQueryPool>( queryPool ),
+                                                                  firstQuery,
+                                                                  queryCount,
+                                                                  sizeof( T ),
+                                                                  reinterpret_cast<void *>( &data ),
+                                                                  static_cast<VkDeviceSize>( stride ),
+                                                                  static_cast<VkQueryResultFlags>( flags ) ) );
+    return createResultValue( result,
+                              data,
+                              VULKAN_HPP_NAMESPACE_STRING "::Device::getQueryPoolResult",
+                              { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eNotReady } );
   }
-
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::AccelerationStructureNV, Dispatch>>::type
-    Device::createAccelerationStructureNVUnique( const AccelerationStructureCreateInfoNV & createInfo,
-                                                 Optional<const AllocationCallbacks>       allocator,
-                                                 Dispatch const &                          d ) const
-  {
-    VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure;
-    Result                                        result = static_cast<Result>( d.vkCreateAccelerationStructureNV(
-      m_device,
-      reinterpret_cast<const VkAccelerationStructureCreateInfoNV *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>(
-        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkAccelerationStructureNV *>( &accelerationStructure ) ) );
-    ObjectDestroy<Device, Dispatch>               deleter( *this, allocator, d );
-    return createResultValue<VULKAN_HPP_NAMESPACE::AccelerationStructureNV, Dispatch>(
-      result,
-      accelerationStructure,
-      VULKAN_HPP_NAMESPACE_STRING "::Device::createAccelerationStructureNVUnique",
-      deleter );
-  }
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
@@ -105842,6 +103920,50 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #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,
+                                                Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyBuffer(
+      m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyBuffer( VULKAN_HPP_NAMESPACE::Buffer        buffer,
+                                                Optional<const AllocationCallbacks> allocator,
+                                                Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyBuffer( m_device,
+                       static_cast<VkBuffer>( buffer ),
+                       reinterpret_cast<const VkAllocationCallbacks *>(
+                         static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Buffer                      buffer,
+                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyBuffer(
+      m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Buffer        buffer,
+                                          Optional<const AllocationCallbacks> allocator,
+                                          Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyBuffer( m_device,
+                       static_cast<VkBuffer>( buffer ),
+                       reinterpret_cast<const VkAllocationCallbacks *>(
+                         static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
     Device::createBufferView( const VULKAN_HPP_NAMESPACE::BufferViewCreateInfo * pCreateInfo,
@@ -105896,54 +104018,768 @@ namespace VULKAN_HPP_NAMESPACE
 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::createCommandPool( const VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo * pCreateInfo,
-                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
-                               VULKAN_HPP_NAMESPACE::CommandPool *                 pCommandPool,
-                               Dispatch const &                                    d ) const VULKAN_HPP_NOEXCEPT
+  VULKAN_HPP_INLINE void Device::destroyBufferView( VULKAN_HPP_NAMESPACE::BufferView                  bufferView,
+                                                    const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                                    Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
-    return static_cast<Result>( d.vkCreateCommandPool( m_device,
-                                                       reinterpret_cast<const VkCommandPoolCreateInfo *>( pCreateInfo ),
-                                                       reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
-                                                       reinterpret_cast<VkCommandPool *>( pCommandPool ) ) );
+    d.vkDestroyBufferView( m_device,
+                           static_cast<VkBufferView>( bufferView ),
+                           reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
 
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::CommandPool>::type
-    Device::createCommandPool( const CommandPoolCreateInfo &       createInfo,
-                               Optional<const AllocationCallbacks> allocator,
-                               Dispatch const &                    d ) const
+  VULKAN_HPP_INLINE void Device::destroyBufferView( VULKAN_HPP_NAMESPACE::BufferView    bufferView,
+                                                    Optional<const AllocationCallbacks> allocator,
+                                                    Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
   {
-    VULKAN_HPP_NAMESPACE::CommandPool commandPool;
-    Result                            result = static_cast<Result>(
-      d.vkCreateCommandPool( m_device,
-                             reinterpret_cast<const VkCommandPoolCreateInfo *>( &createInfo ),
-                             reinterpret_cast<const VkAllocationCallbacks *>(
-                               static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                             reinterpret_cast<VkCommandPool *>( &commandPool ) ) );
-    return createResultValue( result, commandPool, VULKAN_HPP_NAMESPACE_STRING "::Device::createCommandPool" );
+    d.vkDestroyBufferView( m_device,
+                           static_cast<VkBufferView>( bufferView ),
+                           reinterpret_cast<const VkAllocationCallbacks *>(
+                             static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::BufferView                  bufferView,
+                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyBufferView( m_device,
+                           static_cast<VkBufferView>( bufferView ),
+                           reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::BufferView    bufferView,
+                                          Optional<const AllocationCallbacks> allocator,
+                                          Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyBufferView( m_device,
+                           static_cast<VkBufferView>( bufferView ),
+                           reinterpret_cast<const VkAllocationCallbacks *>(
+                             static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::createImage( const VULKAN_HPP_NAMESPACE::ImageCreateInfo *     pCreateInfo,
+                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                         VULKAN_HPP_NAMESPACE::Image *                     pImage,
+                         Dispatch const &                                  d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkCreateImage( m_device,
+                                                 reinterpret_cast<const VkImageCreateInfo *>( pCreateInfo ),
+                                                 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
+                                                 reinterpret_cast<VkImage *>( pImage ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::Image>::type
+                                          Device::createImage( const ImageCreateInfo &             createInfo,
+                         Optional<const AllocationCallbacks> allocator,
+                         Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::Image image;
+    Result                      result = static_cast<Result>(
+      d.vkCreateImage( m_device,
+                       reinterpret_cast<const VkImageCreateInfo *>( &createInfo ),
+                       reinterpret_cast<const VkAllocationCallbacks *>(
+                         static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                       reinterpret_cast<VkImage *>( &image ) ) );
+    return createResultValue( result, image, VULKAN_HPP_NAMESPACE_STRING "::Device::createImage" );
   }
 
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandPool, Dispatch>>::type
-    Device::createCommandPoolUnique( const CommandPoolCreateInfo &       createInfo,
-                                     Optional<const AllocationCallbacks> allocator,
-                                     Dispatch const &                    d ) const
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Image, Dispatch>>::type
+    Device::createImageUnique( const ImageCreateInfo &             createInfo,
+                               Optional<const AllocationCallbacks> allocator,
+                               Dispatch const &                    d ) const
   {
-    VULKAN_HPP_NAMESPACE::CommandPool commandPool;
-    Result                            result = static_cast<Result>(
-      d.vkCreateCommandPool( m_device,
-                             reinterpret_cast<const VkCommandPoolCreateInfo *>( &createInfo ),
-                             reinterpret_cast<const VkAllocationCallbacks *>(
-                               static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                             reinterpret_cast<VkCommandPool *>( &commandPool ) ) );
+    VULKAN_HPP_NAMESPACE::Image image;
+    Result                      result = static_cast<Result>(
+      d.vkCreateImage( m_device,
+                       reinterpret_cast<const VkImageCreateInfo *>( &createInfo ),
+                       reinterpret_cast<const VkAllocationCallbacks *>(
+                         static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                       reinterpret_cast<VkImage *>( &image ) ) );
     ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<VULKAN_HPP_NAMESPACE::CommandPool, Dispatch>(
-      result, commandPool, VULKAN_HPP_NAMESPACE_STRING "::Device::createCommandPoolUnique", deleter );
+    return createResultValue<VULKAN_HPP_NAMESPACE::Image, Dispatch>(
+      result, image, VULKAN_HPP_NAMESPACE_STRING "::Device::createImageUnique", deleter );
+  }
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyImage( VULKAN_HPP_NAMESPACE::Image                       image,
+                                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                               Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyImage(
+      m_device, static_cast<VkImage>( image ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyImage( VULKAN_HPP_NAMESPACE::Image         image,
+                                               Optional<const AllocationCallbacks> allocator,
+                                               Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyImage( m_device,
+                      static_cast<VkImage>( image ),
+                      reinterpret_cast<const VkAllocationCallbacks *>(
+                        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Image                       image,
+                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyImage(
+      m_device, static_cast<VkImage>( image ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Image         image,
+                                          Optional<const AllocationCallbacks> allocator,
+                                          Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyImage( m_device,
+                      static_cast<VkImage>( image ),
+                      reinterpret_cast<const VkAllocationCallbacks *>(
+                        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::getImageSubresourceLayout( VULKAN_HPP_NAMESPACE::Image                    image,
+                                                            const VULKAN_HPP_NAMESPACE::ImageSubresource * pSubresource,
+                                                            VULKAN_HPP_NAMESPACE::SubresourceLayout *      pLayout,
+                                                            Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkGetImageSubresourceLayout( m_device,
+                                   static_cast<VkImage>( image ),
+                                   reinterpret_cast<const VkImageSubresource *>( pSubresource ),
+                                   reinterpret_cast<VkSubresourceLayout *>( pLayout ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::SubresourceLayout
+                                         Device::getImageSubresourceLayout( VULKAN_HPP_NAMESPACE::Image image,
+                                       const ImageSubresource &    subresource,
+                                       Dispatch const &            d ) const VULKAN_HPP_NOEXCEPT
+  {
+    VULKAN_HPP_NAMESPACE::SubresourceLayout layout;
+    d.vkGetImageSubresourceLayout( m_device,
+                                   static_cast<VkImage>( image ),
+                                   reinterpret_cast<const VkImageSubresource *>( &subresource ),
+                                   reinterpret_cast<VkSubresourceLayout *>( &layout ) );
+    return layout;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::createImageView( const VULKAN_HPP_NAMESPACE::ImageViewCreateInfo * pCreateInfo,
+                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                             VULKAN_HPP_NAMESPACE::ImageView *                 pView,
+                             Dispatch const &                                  d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkCreateImageView( m_device,
+                                                     reinterpret_cast<const VkImageViewCreateInfo *>( pCreateInfo ),
+                                                     reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
+                                                     reinterpret_cast<VkImageView *>( pView ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageView>::type
+    Device::createImageView( const ImageViewCreateInfo &         createInfo,
+                             Optional<const AllocationCallbacks> allocator,
+                             Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::ImageView view;
+    Result                          result = static_cast<Result>(
+      d.vkCreateImageView( m_device,
+                           reinterpret_cast<const VkImageViewCreateInfo *>( &createInfo ),
+                           reinterpret_cast<const VkAllocationCallbacks *>(
+                             static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                           reinterpret_cast<VkImageView *>( &view ) ) );
+    return createResultValue( result, view, VULKAN_HPP_NAMESPACE_STRING "::Device::createImageView" );
+  }
+
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ImageView, Dispatch>>::type
+    Device::createImageViewUnique( const ImageViewCreateInfo &         createInfo,
+                                   Optional<const AllocationCallbacks> allocator,
+                                   Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::ImageView view;
+    Result                          result = static_cast<Result>(
+      d.vkCreateImageView( m_device,
+                           reinterpret_cast<const VkImageViewCreateInfo *>( &createInfo ),
+                           reinterpret_cast<const VkAllocationCallbacks *>(
+                             static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                           reinterpret_cast<VkImageView *>( &view ) ) );
+    ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
+    return createResultValue<VULKAN_HPP_NAMESPACE::ImageView, Dispatch>(
+      result, view, VULKAN_HPP_NAMESPACE_STRING "::Device::createImageViewUnique", deleter );
+  }
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyImageView( VULKAN_HPP_NAMESPACE::ImageView                   imageView,
+                                                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                                   Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyImageView(
+      m_device, static_cast<VkImageView>( imageView ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyImageView( VULKAN_HPP_NAMESPACE::ImageView     imageView,
+                                                   Optional<const AllocationCallbacks> allocator,
+                                                   Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyImageView( m_device,
+                          static_cast<VkImageView>( imageView ),
+                          reinterpret_cast<const VkAllocationCallbacks *>(
+                            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::ImageView                   imageView,
+                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyImageView(
+      m_device, static_cast<VkImageView>( imageView ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::ImageView     imageView,
+                                          Optional<const AllocationCallbacks> allocator,
+                                          Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyImageView( m_device,
+                          static_cast<VkImageView>( imageView ),
+                          reinterpret_cast<const VkAllocationCallbacks *>(
+                            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::createShaderModule( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo * pCreateInfo,
+                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks *    pAllocator,
+                                VULKAN_HPP_NAMESPACE::ShaderModule *                 pShaderModule,
+                                Dispatch const &                                     d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkCreateShaderModule( m_device,
+                              reinterpret_cast<const VkShaderModuleCreateInfo *>( pCreateInfo ),
+                              reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
+                              reinterpret_cast<VkShaderModule *>( pShaderModule ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::ShaderModule>::type
+    Device::createShaderModule( const ShaderModuleCreateInfo &      createInfo,
+                                Optional<const AllocationCallbacks> allocator,
+                                Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::ShaderModule shaderModule;
+    Result                             result = static_cast<Result>(
+      d.vkCreateShaderModule( m_device,
+                              reinterpret_cast<const VkShaderModuleCreateInfo *>( &createInfo ),
+                              reinterpret_cast<const VkAllocationCallbacks *>(
+                                static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                              reinterpret_cast<VkShaderModule *>( &shaderModule ) ) );
+    return createResultValue( result, shaderModule, VULKAN_HPP_NAMESPACE_STRING "::Device::createShaderModule" );
+  }
+
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderModule, Dispatch>>::type
+    Device::createShaderModuleUnique( const ShaderModuleCreateInfo &      createInfo,
+                                      Optional<const AllocationCallbacks> allocator,
+                                      Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::ShaderModule shaderModule;
+    Result                             result = static_cast<Result>(
+      d.vkCreateShaderModule( m_device,
+                              reinterpret_cast<const VkShaderModuleCreateInfo *>( &createInfo ),
+                              reinterpret_cast<const VkAllocationCallbacks *>(
+                                static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                              reinterpret_cast<VkShaderModule *>( &shaderModule ) ) );
+    ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
+    return createResultValue<VULKAN_HPP_NAMESPACE::ShaderModule, Dispatch>(
+      result, shaderModule, VULKAN_HPP_NAMESPACE_STRING "::Device::createShaderModuleUnique", deleter );
+  }
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyShaderModule( VULKAN_HPP_NAMESPACE::ShaderModule                shaderModule,
+                                                      const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                                      Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyShaderModule( m_device,
+                             static_cast<VkShaderModule>( shaderModule ),
+                             reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyShaderModule( VULKAN_HPP_NAMESPACE::ShaderModule  shaderModule,
+                                                      Optional<const AllocationCallbacks> allocator,
+                                                      Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyShaderModule( m_device,
+                             static_cast<VkShaderModule>( shaderModule ),
+                             reinterpret_cast<const VkAllocationCallbacks *>(
+                               static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::ShaderModule                shaderModule,
+                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyShaderModule( m_device,
+                             static_cast<VkShaderModule>( shaderModule ),
+                             reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::ShaderModule  shaderModule,
+                                          Optional<const AllocationCallbacks> allocator,
+                                          Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyShaderModule( m_device,
+                             static_cast<VkShaderModule>( shaderModule ),
+                             reinterpret_cast<const VkAllocationCallbacks *>(
+                               static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::createPipelineCache( const VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo * pCreateInfo,
+                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks *     pAllocator,
+                                 VULKAN_HPP_NAMESPACE::PipelineCache *                 pPipelineCache,
+                                 Dispatch const &                                      d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkCreatePipelineCache( m_device,
+                               reinterpret_cast<const VkPipelineCacheCreateInfo *>( pCreateInfo ),
+                               reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
+                               reinterpret_cast<VkPipelineCache *>( pPipelineCache ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::PipelineCache>::type
+    Device::createPipelineCache( const PipelineCacheCreateInfo &     createInfo,
+                                 Optional<const AllocationCallbacks> allocator,
+                                 Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache;
+    Result                              result = static_cast<Result>(
+      d.vkCreatePipelineCache( m_device,
+                               reinterpret_cast<const VkPipelineCacheCreateInfo *>( &createInfo ),
+                               reinterpret_cast<const VkAllocationCallbacks *>(
+                                 static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                               reinterpret_cast<VkPipelineCache *>( &pipelineCache ) ) );
+    return createResultValue( result, pipelineCache, VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineCache" );
+  }
+
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineCache, Dispatch>>::type
+    Device::createPipelineCacheUnique( const PipelineCacheCreateInfo &     createInfo,
+                                       Optional<const AllocationCallbacks> allocator,
+                                       Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache;
+    Result                              result = static_cast<Result>(
+      d.vkCreatePipelineCache( m_device,
+                               reinterpret_cast<const VkPipelineCacheCreateInfo *>( &createInfo ),
+                               reinterpret_cast<const VkAllocationCallbacks *>(
+                                 static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                               reinterpret_cast<VkPipelineCache *>( &pipelineCache ) ) );
+    ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
+    return createResultValue<VULKAN_HPP_NAMESPACE::PipelineCache, Dispatch>(
+      result, pipelineCache, VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineCacheUnique", deleter );
+  }
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyPipelineCache( VULKAN_HPP_NAMESPACE::PipelineCache               pipelineCache,
+                                                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                                       Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyPipelineCache( m_device,
+                              static_cast<VkPipelineCache>( pipelineCache ),
+                              reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyPipelineCache( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
+                                                       Optional<const AllocationCallbacks> allocator,
+                                                       Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyPipelineCache( m_device,
+                              static_cast<VkPipelineCache>( pipelineCache ),
+                              reinterpret_cast<const VkAllocationCallbacks *>(
+                                static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::PipelineCache               pipelineCache,
+                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyPipelineCache( m_device,
+                              static_cast<VkPipelineCache>( pipelineCache ),
+                              reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
+                                          Optional<const AllocationCallbacks> allocator,
+                                          Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyPipelineCache( m_device,
+                              static_cast<VkPipelineCache>( pipelineCache ),
+                              reinterpret_cast<const VkAllocationCallbacks *>(
+                                static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
+                                  size_t *                            pDataSize,
+                                  void *                              pData,
+                                  Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkGetPipelineCacheData( m_device, static_cast<VkPipelineCache>( pipelineCache ), pDataSize, pData ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Uint8_tAllocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
+    Device::getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, Dispatch const & d ) const
+  {
+    std::vector<uint8_t, Uint8_tAllocator> data;
+    size_t                                 dataSize;
+    Result                                 result;
+    do
+    {
+      result = static_cast<Result>(
+        d.vkGetPipelineCacheData( m_device, static_cast<VkPipelineCache>( pipelineCache ), &dataSize, nullptr ) );
+      if ( ( result == Result::eSuccess ) && dataSize )
+      {
+        data.resize( dataSize );
+        result = static_cast<Result>( d.vkGetPipelineCacheData( m_device,
+                                                                static_cast<VkPipelineCache>( pipelineCache ),
+                                                                &dataSize,
+                                                                reinterpret_cast<void *>( data.data() ) ) );
+        VULKAN_HPP_ASSERT( dataSize <= data.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( dataSize < data.size() ) )
+    {
+      data.resize( dataSize );
+    }
+    return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineCacheData" );
+  }
+
+  template <typename Uint8_tAllocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, uint8_t>::value, int>::type>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
+                       Device::getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
+                                  Uint8_tAllocator &                  uint8_tAllocator,
+                                  Dispatch const &                    d ) const
+  {
+    std::vector<uint8_t, Uint8_tAllocator> data( uint8_tAllocator );
+    size_t                                 dataSize;
+    Result                                 result;
+    do
+    {
+      result = static_cast<Result>(
+        d.vkGetPipelineCacheData( m_device, static_cast<VkPipelineCache>( pipelineCache ), &dataSize, nullptr ) );
+      if ( ( result == Result::eSuccess ) && dataSize )
+      {
+        data.resize( dataSize );
+        result = static_cast<Result>( d.vkGetPipelineCacheData( m_device,
+                                                                static_cast<VkPipelineCache>( pipelineCache ),
+                                                                &dataSize,
+                                                                reinterpret_cast<void *>( data.data() ) ) );
+        VULKAN_HPP_ASSERT( dataSize <= data.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( dataSize < data.size() ) )
+    {
+      data.resize( dataSize );
+    }
+    return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineCacheData" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::mergePipelineCaches( VULKAN_HPP_NAMESPACE::PipelineCache         dstCache,
+                                 uint32_t                                    srcCacheCount,
+                                 const VULKAN_HPP_NAMESPACE::PipelineCache * pSrcCaches,
+                                 Dispatch const &                            d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkMergePipelineCaches( m_device,
+                                                         static_cast<VkPipelineCache>( dstCache ),
+                                                         srcCacheCount,
+                                                         reinterpret_cast<const VkPipelineCache *>( pSrcCaches ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
+                                          Device::mergePipelineCaches( VULKAN_HPP_NAMESPACE::PipelineCache                           dstCache,
+                                 ArrayProxy<const VULKAN_HPP_NAMESPACE::PipelineCache> const & srcCaches,
+                                 Dispatch const &                                              d ) const
+  {
+    Result result =
+      static_cast<Result>( d.vkMergePipelineCaches( m_device,
+                                                    static_cast<VkPipelineCache>( dstCache ),
+                                                    srcCaches.size(),
+                                                    reinterpret_cast<const VkPipelineCache *>( srcCaches.data() ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::mergePipelineCaches" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::createGraphicsPipelines( VULKAN_HPP_NAMESPACE::PipelineCache                      pipelineCache,
+                                     uint32_t                                                 createInfoCount,
+                                     const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo * pCreateInfos,
+                                     const VULKAN_HPP_NAMESPACE::AllocationCallbacks *        pAllocator,
+                                     VULKAN_HPP_NAMESPACE::Pipeline *                         pPipelines,
+                                     Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkCreateGraphicsPipelines( m_device,
+                                   static_cast<VkPipelineCache>( pipelineCache ),
+                                   createInfoCount,
+                                   reinterpret_cast<const VkGraphicsPipelineCreateInfo *>( pCreateInfos ),
+                                   reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
+                                   reinterpret_cast<VkPipeline *>( pPipelines ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename PipelineAllocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<Pipeline, PipelineAllocator>>
+                                         Device::createGraphicsPipelines(
+      VULKAN_HPP_NAMESPACE::PipelineCache                                        pipelineCache,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
+      Optional<const AllocationCallbacks>                                        allocator,
+      Dispatch const &                                                           d ) const
+  {
+    std::vector<Pipeline, PipelineAllocator> pipelines( createInfos.size() );
+    Result                                   result = static_cast<Result>(
+      d.vkCreateGraphicsPipelines( m_device,
+                                   static_cast<VkPipelineCache>( pipelineCache ),
+                                   createInfos.size(),
+                                   reinterpret_cast<const VkGraphicsPipelineCreateInfo *>( createInfos.data() ),
+                                   reinterpret_cast<const VkAllocationCallbacks *>(
+                                     static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                   reinterpret_cast<VkPipeline *>( pipelines.data() ) ) );
+    return createResultValue(
+      result,
+      pipelines,
+      VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelines",
+      { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
+  }
+
+  template <typename PipelineAllocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, Pipeline>::value, int>::type>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<Pipeline, PipelineAllocator>>
+                                         Device::createGraphicsPipelines(
+      VULKAN_HPP_NAMESPACE::PipelineCache                                        pipelineCache,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
+      Optional<const AllocationCallbacks>                                        allocator,
+      PipelineAllocator &                                                        pipelineAllocator,
+      Dispatch const &                                                           d ) const
+  {
+    std::vector<Pipeline, PipelineAllocator> pipelines( createInfos.size(), pipelineAllocator );
+    Result                                   result = static_cast<Result>(
+      d.vkCreateGraphicsPipelines( m_device,
+                                   static_cast<VkPipelineCache>( pipelineCache ),
+                                   createInfos.size(),
+                                   reinterpret_cast<const VkGraphicsPipelineCreateInfo *>( createInfos.data() ),
+                                   reinterpret_cast<const VkAllocationCallbacks *>(
+                                     static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                   reinterpret_cast<VkPipeline *>( pipelines.data() ) ) );
+    return createResultValue(
+      result,
+      pipelines,
+      VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelines",
+      { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<Pipeline>
+    Device::createGraphicsPipeline( VULKAN_HPP_NAMESPACE::PipelineCache                      pipelineCache,
+                                    const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo & createInfo,
+                                    Optional<const AllocationCallbacks>                      allocator,
+                                    Dispatch const &                                         d ) const
+  {
+    Pipeline pipeline;
+    Result   result = static_cast<Result>(
+      d.vkCreateGraphicsPipelines( m_device,
+                                   static_cast<VkPipelineCache>( pipelineCache ),
+                                   1,
+                                   reinterpret_cast<const VkGraphicsPipelineCreateInfo *>( &createInfo ),
+                                   reinterpret_cast<const VkAllocationCallbacks *>(
+                                     static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                   reinterpret_cast<VkPipeline *>( &pipeline ) ) );
+    return createResultValue(
+      result,
+      pipeline,
+      VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipeline",
+      { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
+  }
+
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch, typename PipelineAllocator>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
+                                         Device::createGraphicsPipelinesUnique(
+      VULKAN_HPP_NAMESPACE::PipelineCache                                        pipelineCache,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
+      Optional<const AllocationCallbacks>                                        allocator,
+      Dispatch const &                                                           d ) const
+  {
+    std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator> uniquePipelines;
+    std::vector<Pipeline>                                            pipelines( createInfos.size() );
+    Result                                                           result = static_cast<Result>(
+      d.vkCreateGraphicsPipelines( m_device,
+                                   static_cast<VkPipelineCache>( pipelineCache ),
+                                   createInfos.size(),
+                                   reinterpret_cast<const VkGraphicsPipelineCreateInfo *>( createInfos.data() ),
+                                   reinterpret_cast<const VkAllocationCallbacks *>(
+                                     static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                   reinterpret_cast<VkPipeline *>( pipelines.data() ) ) );
+    if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) ||
+         ( result == VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) )
+    {
+      uniquePipelines.reserve( createInfos.size() );
+      ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
+      for ( size_t i = 0; i < createInfos.size(); i++ )
+      {
+        uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipelines[i], deleter ) );
+      }
+    }
+    return createResultValue(
+      result,
+      std::move( uniquePipelines ),
+      VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelinesUnique",
+      { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
+  }
+
+  template <
+    typename Dispatch,
+    typename PipelineAllocator,
+    typename B,
+    typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
+                                         Device::createGraphicsPipelinesUnique(
+      VULKAN_HPP_NAMESPACE::PipelineCache                                        pipelineCache,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
+      Optional<const AllocationCallbacks>                                        allocator,
+      PipelineAllocator &                                                        pipelineAllocator,
+      Dispatch const &                                                           d ) const
+  {
+    std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator> uniquePipelines( pipelineAllocator );
+    std::vector<Pipeline>                                            pipelines( createInfos.size() );
+    Result                                                           result = static_cast<Result>(
+      d.vkCreateGraphicsPipelines( m_device,
+                                   static_cast<VkPipelineCache>( pipelineCache ),
+                                   createInfos.size(),
+                                   reinterpret_cast<const VkGraphicsPipelineCreateInfo *>( createInfos.data() ),
+                                   reinterpret_cast<const VkAllocationCallbacks *>(
+                                     static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                   reinterpret_cast<VkPipeline *>( pipelines.data() ) ) );
+    if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) ||
+         ( result == VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) )
+    {
+      uniquePipelines.reserve( createInfos.size() );
+      ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
+      for ( size_t i = 0; i < createInfos.size(); i++ )
+      {
+        uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipelines[i], deleter ) );
+      }
+    }
+    return createResultValue(
+      result,
+      std::move( uniquePipelines ),
+      VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelinesUnique",
+      { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<UniqueHandle<Pipeline, Dispatch>>
+    Device::createGraphicsPipelineUnique( VULKAN_HPP_NAMESPACE::PipelineCache                      pipelineCache,
+                                          const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo & createInfo,
+                                          Optional<const AllocationCallbacks>                      allocator,
+                                          Dispatch const &                                         d ) const
+  {
+    Pipeline pipeline;
+    Result   result = static_cast<Result>(
+      d.vkCreateGraphicsPipelines( m_device,
+                                   static_cast<VkPipelineCache>( pipelineCache ),
+                                   1,
+                                   reinterpret_cast<const VkGraphicsPipelineCreateInfo *>( &createInfo ),
+                                   reinterpret_cast<const VkAllocationCallbacks *>(
+                                     static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                   reinterpret_cast<VkPipeline *>( &pipeline ) ) );
+    ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
+    return createResultValue<Pipeline, Dispatch>(
+      result,
+      pipeline,
+      VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelineUnique",
+      { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT },
+      deleter );
   }
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@@ -106145,158 +104981,349 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyPipeline( VULKAN_HPP_NAMESPACE::Pipeline                    pipeline,
+                                                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                                  Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyPipeline(
+      m_device, static_cast<VkPipeline>( pipeline ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyPipeline( VULKAN_HPP_NAMESPACE::Pipeline      pipeline,
+                                                  Optional<const AllocationCallbacks> allocator,
+                                                  Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyPipeline( m_device,
+                         static_cast<VkPipeline>( pipeline ),
+                         reinterpret_cast<const VkAllocationCallbacks *>(
+                           static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Pipeline                    pipeline,
+                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyPipeline(
+      m_device, static_cast<VkPipeline>( pipeline ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Pipeline      pipeline,
+                                          Optional<const AllocationCallbacks> allocator,
+                                          Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyPipeline( m_device,
+                         static_cast<VkPipeline>( pipeline ),
+                         reinterpret_cast<const VkAllocationCallbacks *>(
+                           static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::createCuFunctionNVX( const VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX * pCreateInfo,
-                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks *     pAllocator,
-                                 VULKAN_HPP_NAMESPACE::CuFunctionNVX *                 pFunction,
-                                 Dispatch const &                                      d ) const VULKAN_HPP_NOEXCEPT
+    Device::createPipelineLayout( const VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo * pCreateInfo,
+                                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks *      pAllocator,
+                                  VULKAN_HPP_NAMESPACE::PipelineLayout *                 pPipelineLayout,
+                                  Dispatch const &                                       d ) const VULKAN_HPP_NOEXCEPT
   {
     return static_cast<Result>(
-      d.vkCreateCuFunctionNVX( m_device,
-                               reinterpret_cast<const VkCuFunctionCreateInfoNVX *>( pCreateInfo ),
-                               reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
-                               reinterpret_cast<VkCuFunctionNVX *>( pFunction ) ) );
+      d.vkCreatePipelineLayout( m_device,
+                                reinterpret_cast<const VkPipelineLayoutCreateInfo *>( pCreateInfo ),
+                                reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
+                                reinterpret_cast<VkPipelineLayout *>( pPipelineLayout ) ) );
   }
 
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::CuFunctionNVX>::type
-    Device::createCuFunctionNVX( const CuFunctionCreateInfoNVX &     createInfo,
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::PipelineLayout>::type
+    Device::createPipelineLayout( const PipelineLayoutCreateInfo &    createInfo,
+                                  Optional<const AllocationCallbacks> allocator,
+                                  Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout;
+    Result                               result = static_cast<Result>(
+      d.vkCreatePipelineLayout( m_device,
+                                reinterpret_cast<const VkPipelineLayoutCreateInfo *>( &createInfo ),
+                                reinterpret_cast<const VkAllocationCallbacks *>(
+                                  static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                reinterpret_cast<VkPipelineLayout *>( &pipelineLayout ) ) );
+    return createResultValue( result, pipelineLayout, VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineLayout" );
+  }
+
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineLayout, Dispatch>>::type
+    Device::createPipelineLayoutUnique( const PipelineLayoutCreateInfo &    createInfo,
+                                        Optional<const AllocationCallbacks> allocator,
+                                        Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout;
+    Result                               result = static_cast<Result>(
+      d.vkCreatePipelineLayout( m_device,
+                                reinterpret_cast<const VkPipelineLayoutCreateInfo *>( &createInfo ),
+                                reinterpret_cast<const VkAllocationCallbacks *>(
+                                  static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                reinterpret_cast<VkPipelineLayout *>( &pipelineLayout ) ) );
+    ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
+    return createResultValue<VULKAN_HPP_NAMESPACE::PipelineLayout, Dispatch>(
+      result, pipelineLayout, VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineLayoutUnique", deleter );
+  }
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyPipelineLayout( VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout,
+                                                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                                        Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyPipelineLayout( m_device,
+                               static_cast<VkPipelineLayout>( pipelineLayout ),
+                               reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyPipelineLayout( VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout,
+                                                        Optional<const AllocationCallbacks>  allocator,
+                                                        Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyPipelineLayout( m_device,
+                               static_cast<VkPipelineLayout>( pipelineLayout ),
+                               reinterpret_cast<const VkAllocationCallbacks *>(
+                                 static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::PipelineLayout              pipelineLayout,
+                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyPipelineLayout( m_device,
+                               static_cast<VkPipelineLayout>( pipelineLayout ),
+                               reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout,
+                                          Optional<const AllocationCallbacks>  allocator,
+                                          Dispatch const &                     d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyPipelineLayout( m_device,
+                               static_cast<VkPipelineLayout>( pipelineLayout ),
+                               reinterpret_cast<const VkAllocationCallbacks *>(
+                                 static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::createSampler( const VULKAN_HPP_NAMESPACE::SamplerCreateInfo *   pCreateInfo,
+                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                           VULKAN_HPP_NAMESPACE::Sampler *                   pSampler,
+                           Dispatch const &                                  d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkCreateSampler( m_device,
+                                                   reinterpret_cast<const VkSamplerCreateInfo *>( pCreateInfo ),
+                                                   reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
+                                                   reinterpret_cast<VkSampler *>( pSampler ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::Sampler>::type
+    Device::createSampler( const SamplerCreateInfo &           createInfo,
+                           Optional<const AllocationCallbacks> allocator,
+                           Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::Sampler sampler;
+    Result                        result = static_cast<Result>(
+      d.vkCreateSampler( m_device,
+                         reinterpret_cast<const VkSamplerCreateInfo *>( &createInfo ),
+                         reinterpret_cast<const VkAllocationCallbacks *>(
+                           static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                         reinterpret_cast<VkSampler *>( &sampler ) ) );
+    return createResultValue( result, sampler, VULKAN_HPP_NAMESPACE_STRING "::Device::createSampler" );
+  }
+
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Sampler, Dispatch>>::type
+    Device::createSamplerUnique( const SamplerCreateInfo &           createInfo,
                                  Optional<const AllocationCallbacks> allocator,
                                  Dispatch const &                    d ) const
   {
-    VULKAN_HPP_NAMESPACE::CuFunctionNVX function;
-    Result                              result = static_cast<Result>(
-      d.vkCreateCuFunctionNVX( m_device,
-                               reinterpret_cast<const VkCuFunctionCreateInfoNVX *>( &createInfo ),
-                               reinterpret_cast<const VkAllocationCallbacks *>(
-                                 static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                               reinterpret_cast<VkCuFunctionNVX *>( &function ) ) );
-    return createResultValue( result, function, VULKAN_HPP_NAMESPACE_STRING "::Device::createCuFunctionNVX" );
-  }
-
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CuFunctionNVX, Dispatch>>::type
-    Device::createCuFunctionNVXUnique( const CuFunctionCreateInfoNVX &     createInfo,
-                                       Optional<const AllocationCallbacks> allocator,
-                                       Dispatch const &                    d ) const
-  {
-    VULKAN_HPP_NAMESPACE::CuFunctionNVX function;
-    Result                              result = static_cast<Result>(
-      d.vkCreateCuFunctionNVX( m_device,
-                               reinterpret_cast<const VkCuFunctionCreateInfoNVX *>( &createInfo ),
-                               reinterpret_cast<const VkAllocationCallbacks *>(
-                                 static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                               reinterpret_cast<VkCuFunctionNVX *>( &function ) ) );
+    VULKAN_HPP_NAMESPACE::Sampler sampler;
+    Result                        result = static_cast<Result>(
+      d.vkCreateSampler( m_device,
+                         reinterpret_cast<const VkSamplerCreateInfo *>( &createInfo ),
+                         reinterpret_cast<const VkAllocationCallbacks *>(
+                           static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                         reinterpret_cast<VkSampler *>( &sampler ) ) );
     ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<VULKAN_HPP_NAMESPACE::CuFunctionNVX, Dispatch>(
-      result, function, VULKAN_HPP_NAMESPACE_STRING "::Device::createCuFunctionNVXUnique", deleter );
+    return createResultValue<VULKAN_HPP_NAMESPACE::Sampler, Dispatch>(
+      result, sampler, VULKAN_HPP_NAMESPACE_STRING "::Device::createSamplerUnique", deleter );
   }
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::createCuModuleNVX( const VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX * pCreateInfo,
-                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
-                               VULKAN_HPP_NAMESPACE::CuModuleNVX *                 pModule,
-                               Dispatch const &                                    d ) const VULKAN_HPP_NOEXCEPT
+  VULKAN_HPP_INLINE void Device::destroySampler( VULKAN_HPP_NAMESPACE::Sampler                     sampler,
+                                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                                 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
-    return static_cast<Result>( d.vkCreateCuModuleNVX( m_device,
-                                                       reinterpret_cast<const VkCuModuleCreateInfoNVX *>( pCreateInfo ),
-                                                       reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
-                                                       reinterpret_cast<VkCuModuleNVX *>( pModule ) ) );
+    d.vkDestroySampler(
+      m_device, static_cast<VkSampler>( sampler ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
 
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::CuModuleNVX>::type
-    Device::createCuModuleNVX( const CuModuleCreateInfoNVX &       createInfo,
-                               Optional<const AllocationCallbacks> allocator,
-                               Dispatch const &                    d ) const
+  VULKAN_HPP_INLINE void Device::destroySampler( VULKAN_HPP_NAMESPACE::Sampler       sampler,
+                                                 Optional<const AllocationCallbacks> allocator,
+                                                 Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
   {
-    VULKAN_HPP_NAMESPACE::CuModuleNVX module;
-    Result                            result = static_cast<Result>(
-      d.vkCreateCuModuleNVX( m_device,
-                             reinterpret_cast<const VkCuModuleCreateInfoNVX *>( &createInfo ),
-                             reinterpret_cast<const VkAllocationCallbacks *>(
-                               static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                             reinterpret_cast<VkCuModuleNVX *>( &module ) ) );
-    return createResultValue( result, module, VULKAN_HPP_NAMESPACE_STRING "::Device::createCuModuleNVX" );
+    d.vkDestroySampler( m_device,
+                        static_cast<VkSampler>( sampler ),
+                        reinterpret_cast<const VkAllocationCallbacks *>(
+                          static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Sampler                     sampler,
+                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroySampler(
+      m_device, static_cast<VkSampler>( sampler ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
 
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CuModuleNVX, Dispatch>>::type
-    Device::createCuModuleNVXUnique( const CuModuleCreateInfoNVX &       createInfo,
-                                     Optional<const AllocationCallbacks> allocator,
-                                     Dispatch const &                    d ) const
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Sampler       sampler,
+                                          Optional<const AllocationCallbacks> allocator,
+                                          Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
   {
-    VULKAN_HPP_NAMESPACE::CuModuleNVX module;
-    Result                            result = static_cast<Result>(
-      d.vkCreateCuModuleNVX( m_device,
-                             reinterpret_cast<const VkCuModuleCreateInfoNVX *>( &createInfo ),
-                             reinterpret_cast<const VkAllocationCallbacks *>(
-                               static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                             reinterpret_cast<VkCuModuleNVX *>( &module ) ) );
-    ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<VULKAN_HPP_NAMESPACE::CuModuleNVX, Dispatch>(
-      result, module, VULKAN_HPP_NAMESPACE_STRING "::Device::createCuModuleNVXUnique", deleter );
+    d.vkDestroySampler( m_device,
+                        static_cast<VkSampler>( sampler ),
+                        reinterpret_cast<const VkAllocationCallbacks *>(
+                          static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
   }
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::createDeferredOperationKHR( const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                        VULKAN_HPP_NAMESPACE::DeferredOperationKHR *      pDeferredOperation,
-                                        Dispatch const &                                  d ) const VULKAN_HPP_NOEXCEPT
+    Device::createDescriptorSetLayout( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo * pCreateInfo,
+                                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *           pAllocator,
+                                       VULKAN_HPP_NAMESPACE::DescriptorSetLayout *                 pSetLayout,
+                                       Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     return static_cast<Result>(
-      d.vkCreateDeferredOperationKHR( m_device,
-                                      reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
-                                      reinterpret_cast<VkDeferredOperationKHR *>( pDeferredOperation ) ) );
+      d.vkCreateDescriptorSetLayout( m_device,
+                                     reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( pCreateInfo ),
+                                     reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
+                                     reinterpret_cast<VkDescriptorSetLayout *>( pSetLayout ) ) );
   }
 
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::DeferredOperationKHR>::type
-    Device::createDeferredOperationKHR( Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorSetLayout>::type
+    Device::createDescriptorSetLayout( const DescriptorSetLayoutCreateInfo & createInfo,
+                                       Optional<const AllocationCallbacks>   allocator,
+                                       Dispatch const &                      d ) const
   {
-    VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation;
-    Result                                     result = static_cast<Result>(
-      d.vkCreateDeferredOperationKHR( m_device,
-                                      reinterpret_cast<const VkAllocationCallbacks *>(
-                                        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                      reinterpret_cast<VkDeferredOperationKHR *>( &deferredOperation ) ) );
-    return createResultValue(
-      result, deferredOperation, VULKAN_HPP_NAMESPACE_STRING "::Device::createDeferredOperationKHR" );
+    VULKAN_HPP_NAMESPACE::DescriptorSetLayout setLayout;
+    Result                                    result = static_cast<Result>(
+      d.vkCreateDescriptorSetLayout( m_device,
+                                     reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ),
+                                     reinterpret_cast<const VkAllocationCallbacks *>(
+                                       static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                     reinterpret_cast<VkDescriptorSetLayout *>( &setLayout ) ) );
+    return createResultValue( result, setLayout, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorSetLayout" );
   }
 
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DeferredOperationKHR, Dispatch>>::type
-    Device::createDeferredOperationKHRUnique( Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSetLayout, Dispatch>>::type
+    Device::createDescriptorSetLayoutUnique( const DescriptorSetLayoutCreateInfo & createInfo,
+                                             Optional<const AllocationCallbacks>   allocator,
+                                             Dispatch const &                      d ) const
   {
-    VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation;
-    Result                                     result = static_cast<Result>(
-      d.vkCreateDeferredOperationKHR( m_device,
-                                      reinterpret_cast<const VkAllocationCallbacks *>(
-                                        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                      reinterpret_cast<VkDeferredOperationKHR *>( &deferredOperation ) ) );
+    VULKAN_HPP_NAMESPACE::DescriptorSetLayout setLayout;
+    Result                                    result = static_cast<Result>(
+      d.vkCreateDescriptorSetLayout( m_device,
+                                     reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ),
+                                     reinterpret_cast<const VkAllocationCallbacks *>(
+                                       static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                     reinterpret_cast<VkDescriptorSetLayout *>( &setLayout ) ) );
     ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<VULKAN_HPP_NAMESPACE::DeferredOperationKHR, Dispatch>(
-      result, deferredOperation, VULKAN_HPP_NAMESPACE_STRING "::Device::createDeferredOperationKHRUnique", deleter );
+    return createResultValue<VULKAN_HPP_NAMESPACE::DescriptorSetLayout, Dispatch>(
+      result, setLayout, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorSetLayoutUnique", deleter );
   }
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    Device::destroyDescriptorSetLayout( VULKAN_HPP_NAMESPACE::DescriptorSetLayout         descriptorSetLayout,
+                                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                        Dispatch const &                                  d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyDescriptorSetLayout( m_device,
+                                    static_cast<VkDescriptorSetLayout>( descriptorSetLayout ),
+                                    reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    Device::destroyDescriptorSetLayout( VULKAN_HPP_NAMESPACE::DescriptorSetLayout descriptorSetLayout,
+                                        Optional<const AllocationCallbacks>       allocator,
+                                        Dispatch const &                          d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyDescriptorSetLayout( m_device,
+                                    static_cast<VkDescriptorSetLayout>( descriptorSetLayout ),
+                                    reinterpret_cast<const VkAllocationCallbacks *>(
+                                      static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::DescriptorSetLayout         descriptorSetLayout,
+                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyDescriptorSetLayout( m_device,
+                                    static_cast<VkDescriptorSetLayout>( descriptorSetLayout ),
+                                    reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::DescriptorSetLayout descriptorSetLayout,
+                                          Optional<const AllocationCallbacks>       allocator,
+                                          Dispatch const &                          d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyDescriptorSetLayout( m_device,
+                                    static_cast<VkDescriptorSetLayout>( descriptorSetLayout ),
+                                    reinterpret_cast<const VkAllocationCallbacks *>(
+                                      static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
     Device::createDescriptorPool( const VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo * pCreateInfo,
@@ -106351,60 +105378,2517 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool,
+                                                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                                        Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyDescriptorPool( m_device,
+                               static_cast<VkDescriptorPool>( descriptorPool ),
+                               reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool,
+                                                        Optional<const AllocationCallbacks>  allocator,
+                                                        Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyDescriptorPool( m_device,
+                               static_cast<VkDescriptorPool>( descriptorPool ),
+                               reinterpret_cast<const VkAllocationCallbacks *>(
+                                 static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::DescriptorPool              descriptorPool,
+                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyDescriptorPool( m_device,
+                               static_cast<VkDescriptorPool>( descriptorPool ),
+                               reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool,
+                                          Optional<const AllocationCallbacks>  allocator,
+                                          Dispatch const &                     d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyDescriptorPool( m_device,
+                               static_cast<VkDescriptorPool>( descriptorPool ),
+                               reinterpret_cast<const VkAllocationCallbacks *>(
+                                 static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::resetDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool           descriptorPool,
+                                                        VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags,
+                                                        Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkResetDescriptorPool(
+      m_device, static_cast<VkDescriptorPool>( descriptorPool ), static_cast<VkDescriptorPoolResetFlags>( flags ) ) );
+  }
+#else
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<void>::type
+    Device::resetDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool,
+                                 VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags,
+                                 Dispatch const & d ) const
+  {
+    Result result = static_cast<Result>( d.vkResetDescriptorPool(
+      m_device, static_cast<VkDescriptorPool>( descriptorPool ), static_cast<VkDescriptorPoolResetFlags>( flags ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::resetDescriptorPool" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::createDescriptorSetLayout( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo * pCreateInfo,
-                                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *           pAllocator,
-                                       VULKAN_HPP_NAMESPACE::DescriptorSetLayout *                 pSetLayout,
-                                       Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+    Device::allocateDescriptorSets( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo * pAllocateInfo,
+                                    VULKAN_HPP_NAMESPACE::DescriptorSet *                   pDescriptorSets,
+                                    Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     return static_cast<Result>(
-      d.vkCreateDescriptorSetLayout( m_device,
-                                     reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( pCreateInfo ),
-                                     reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
-                                     reinterpret_cast<VkDescriptorSetLayout *>( pSetLayout ) ) );
+      d.vkAllocateDescriptorSets( m_device,
+                                  reinterpret_cast<const VkDescriptorSetAllocateInfo *>( pAllocateInfo ),
+                                  reinterpret_cast<VkDescriptorSet *>( pDescriptorSets ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename DescriptorSetAllocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<std::vector<DescriptorSet, DescriptorSetAllocator>>::type
+    Device::allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo, Dispatch const & d ) const
+  {
+    std::vector<DescriptorSet, DescriptorSetAllocator> descriptorSets( allocateInfo.descriptorSetCount );
+    Result                                             result = static_cast<Result>(
+      d.vkAllocateDescriptorSets( m_device,
+                                  reinterpret_cast<const VkDescriptorSetAllocateInfo *>( &allocateInfo ),
+                                  reinterpret_cast<VkDescriptorSet *>( descriptorSets.data() ) ) );
+    return createResultValue( result, descriptorSets, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSets" );
+  }
+
+  template <typename DescriptorSetAllocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, DescriptorSet>::value, int>::type>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<std::vector<DescriptorSet, DescriptorSetAllocator>>::type
+    Device::allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo,
+                                    DescriptorSetAllocator &          descriptorSetAllocator,
+                                    Dispatch const &                  d ) const
+  {
+    std::vector<DescriptorSet, DescriptorSetAllocator> descriptorSets( allocateInfo.descriptorSetCount,
+                                                                       descriptorSetAllocator );
+    Result                                             result = static_cast<Result>(
+      d.vkAllocateDescriptorSets( m_device,
+                                  reinterpret_cast<const VkDescriptorSetAllocateInfo *>( &allocateInfo ),
+                                  reinterpret_cast<VkDescriptorSet *>( descriptorSets.data() ) ) );
+    return createResultValue( result, descriptorSets, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSets" );
+  }
+
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch, typename DescriptorSetAllocator>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<std::vector<UniqueHandle<DescriptorSet, Dispatch>, DescriptorSetAllocator>>::type
+    Device::allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo, Dispatch const & d ) const
+  {
+    std::vector<UniqueHandle<DescriptorSet, Dispatch>, DescriptorSetAllocator> uniqueDescriptorSets;
+    std::vector<DescriptorSet> descriptorSets( allocateInfo.descriptorSetCount );
+    Result                     result = static_cast<Result>(
+      d.vkAllocateDescriptorSets( m_device,
+                                  reinterpret_cast<const VkDescriptorSetAllocateInfo *>( &allocateInfo ),
+                                  reinterpret_cast<VkDescriptorSet *>( descriptorSets.data() ) ) );
+    if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess )
+    {
+      uniqueDescriptorSets.reserve( allocateInfo.descriptorSetCount );
+      PoolFree<Device, DescriptorPool, Dispatch> deleter( *this, allocateInfo.descriptorPool, d );
+      for ( size_t i = 0; i < allocateInfo.descriptorSetCount; i++ )
+      {
+        uniqueDescriptorSets.push_back( UniqueHandle<DescriptorSet, Dispatch>( descriptorSets[i], deleter ) );
+      }
+    }
+    return createResultValue(
+      result, std::move( uniqueDescriptorSets ), VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSetsUnique" );
+  }
+
+  template <typename Dispatch,
+            typename DescriptorSetAllocator,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<DescriptorSet, Dispatch>>::value,
+                                    int>::type>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<std::vector<UniqueHandle<DescriptorSet, Dispatch>, DescriptorSetAllocator>>::type
+    Device::allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo,
+                                          DescriptorSetAllocator &          descriptorSetAllocator,
+                                          Dispatch const &                  d ) const
+  {
+    std::vector<UniqueHandle<DescriptorSet, Dispatch>, DescriptorSetAllocator> uniqueDescriptorSets(
+      descriptorSetAllocator );
+    std::vector<DescriptorSet> descriptorSets( allocateInfo.descriptorSetCount );
+    Result                     result = static_cast<Result>(
+      d.vkAllocateDescriptorSets( m_device,
+                                  reinterpret_cast<const VkDescriptorSetAllocateInfo *>( &allocateInfo ),
+                                  reinterpret_cast<VkDescriptorSet *>( descriptorSets.data() ) ) );
+    if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess )
+    {
+      uniqueDescriptorSets.reserve( allocateInfo.descriptorSetCount );
+      PoolFree<Device, DescriptorPool, Dispatch> deleter( *this, allocateInfo.descriptorPool, d );
+      for ( size_t i = 0; i < allocateInfo.descriptorSetCount; i++ )
+      {
+        uniqueDescriptorSets.push_back( UniqueHandle<DescriptorSet, Dispatch>( descriptorSets[i], deleter ) );
+      }
+    }
+    return createResultValue(
+      result, std::move( uniqueDescriptorSets ), VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSetsUnique" );
+  }
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::freeDescriptorSets( VULKAN_HPP_NAMESPACE::DescriptorPool        descriptorPool,
+                                                       uint32_t                                    descriptorSetCount,
+                                                       const VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets,
+                                                       Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkFreeDescriptorSets( m_device,
+                              static_cast<VkDescriptorPool>( descriptorPool ),
+                              descriptorSetCount,
+                              reinterpret_cast<const VkDescriptorSet *>( pDescriptorSets ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<void>::type
+    Device::freeDescriptorSets( VULKAN_HPP_NAMESPACE::DescriptorPool                          descriptorPool,
+                                ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets,
+                                Dispatch const &                                              d ) const
+  {
+    Result result = static_cast<Result>(
+      d.vkFreeDescriptorSets( m_device,
+                              static_cast<VkDescriptorPool>( descriptorPool ),
+                              descriptorSets.size(),
+                              reinterpret_cast<const VkDescriptorSet *>( descriptorSets.data() ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::freeDescriptorSets" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::free( VULKAN_HPP_NAMESPACE::DescriptorPool        descriptorPool,
+                                         uint32_t                                    descriptorSetCount,
+                                         const VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets,
+                                         Dispatch const &                            d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkFreeDescriptorSets( m_device,
+                              static_cast<VkDescriptorPool>( descriptorPool ),
+                              descriptorSetCount,
+                              reinterpret_cast<const VkDescriptorSet *>( pDescriptorSets ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<void>::type
+    Device::free( VULKAN_HPP_NAMESPACE::DescriptorPool                          descriptorPool,
+                  ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets,
+                  Dispatch const &                                              d ) const
+  {
+    Result result = static_cast<Result>(
+      d.vkFreeDescriptorSets( m_device,
+                              static_cast<VkDescriptorPool>( descriptorPool ),
+                              descriptorSets.size(),
+                              reinterpret_cast<const VkDescriptorSet *>( descriptorSets.data() ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::free" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    Device::updateDescriptorSets( uint32_t                                         descriptorWriteCount,
+                                  const VULKAN_HPP_NAMESPACE::WriteDescriptorSet * pDescriptorWrites,
+                                  uint32_t                                         descriptorCopyCount,
+                                  const VULKAN_HPP_NAMESPACE::CopyDescriptorSet *  pDescriptorCopies,
+                                  Dispatch const &                                 d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkUpdateDescriptorSets( m_device,
+                              descriptorWriteCount,
+                              reinterpret_cast<const VkWriteDescriptorSet *>( pDescriptorWrites ),
+                              descriptorCopyCount,
+                              reinterpret_cast<const VkCopyDescriptorSet *>( pDescriptorCopies ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    Device::updateDescriptorSets( ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites,
+                                  ArrayProxy<const VULKAN_HPP_NAMESPACE::CopyDescriptorSet> const &  descriptorCopies,
+                                  Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkUpdateDescriptorSets( m_device,
+                              descriptorWrites.size(),
+                              reinterpret_cast<const VkWriteDescriptorSet *>( descriptorWrites.data() ),
+                              descriptorCopies.size(),
+                              reinterpret_cast<const VkCopyDescriptorSet *>( descriptorCopies.data() ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::createFramebuffer( const VULKAN_HPP_NAMESPACE::FramebufferCreateInfo * pCreateInfo,
+                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
+                               VULKAN_HPP_NAMESPACE::Framebuffer *                 pFramebuffer,
+                               Dispatch const &                                    d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkCreateFramebuffer( m_device,
+                                                       reinterpret_cast<const VkFramebufferCreateInfo *>( pCreateInfo ),
+                                                       reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
+                                                       reinterpret_cast<VkFramebuffer *>( pFramebuffer ) ) );
   }
 
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorSetLayout>::type
-    Device::createDescriptorSetLayout( const DescriptorSetLayoutCreateInfo & createInfo,
-                                       Optional<const AllocationCallbacks>   allocator,
-                                       Dispatch const &                      d ) const
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::Framebuffer>::type
+    Device::createFramebuffer( const FramebufferCreateInfo &       createInfo,
+                               Optional<const AllocationCallbacks> allocator,
+                               Dispatch const &                    d ) const
   {
-    VULKAN_HPP_NAMESPACE::DescriptorSetLayout setLayout;
-    Result                                    result = static_cast<Result>(
-      d.vkCreateDescriptorSetLayout( m_device,
-                                     reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ),
-                                     reinterpret_cast<const VkAllocationCallbacks *>(
-                                       static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                     reinterpret_cast<VkDescriptorSetLayout *>( &setLayout ) ) );
-    return createResultValue( result, setLayout, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorSetLayout" );
+    VULKAN_HPP_NAMESPACE::Framebuffer framebuffer;
+    Result                            result = static_cast<Result>(
+      d.vkCreateFramebuffer( m_device,
+                             reinterpret_cast<const VkFramebufferCreateInfo *>( &createInfo ),
+                             reinterpret_cast<const VkAllocationCallbacks *>(
+                               static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                             reinterpret_cast<VkFramebuffer *>( &framebuffer ) ) );
+    return createResultValue( result, framebuffer, VULKAN_HPP_NAMESPACE_STRING "::Device::createFramebuffer" );
   }
 
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSetLayout, Dispatch>>::type
-    Device::createDescriptorSetLayoutUnique( const DescriptorSetLayoutCreateInfo & createInfo,
-                                             Optional<const AllocationCallbacks>   allocator,
-                                             Dispatch const &                      d ) const
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Framebuffer, Dispatch>>::type
+    Device::createFramebufferUnique( const FramebufferCreateInfo &       createInfo,
+                                     Optional<const AllocationCallbacks> allocator,
+                                     Dispatch const &                    d ) const
   {
-    VULKAN_HPP_NAMESPACE::DescriptorSetLayout setLayout;
-    Result                                    result = static_cast<Result>(
-      d.vkCreateDescriptorSetLayout( m_device,
-                                     reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ),
-                                     reinterpret_cast<const VkAllocationCallbacks *>(
-                                       static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                     reinterpret_cast<VkDescriptorSetLayout *>( &setLayout ) ) );
+    VULKAN_HPP_NAMESPACE::Framebuffer framebuffer;
+    Result                            result = static_cast<Result>(
+      d.vkCreateFramebuffer( m_device,
+                             reinterpret_cast<const VkFramebufferCreateInfo *>( &createInfo ),
+                             reinterpret_cast<const VkAllocationCallbacks *>(
+                               static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                             reinterpret_cast<VkFramebuffer *>( &framebuffer ) ) );
     ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<VULKAN_HPP_NAMESPACE::DescriptorSetLayout, Dispatch>(
-      result, setLayout, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorSetLayoutUnique", deleter );
+    return createResultValue<VULKAN_HPP_NAMESPACE::Framebuffer, Dispatch>(
+      result, framebuffer, VULKAN_HPP_NAMESPACE_STRING "::Device::createFramebufferUnique", deleter );
   }
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyFramebuffer( VULKAN_HPP_NAMESPACE::Framebuffer                 framebuffer,
+                                                     const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                                     Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyFramebuffer( m_device,
+                            static_cast<VkFramebuffer>( framebuffer ),
+                            reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyFramebuffer( VULKAN_HPP_NAMESPACE::Framebuffer   framebuffer,
+                                                     Optional<const AllocationCallbacks> allocator,
+                                                     Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyFramebuffer( m_device,
+                            static_cast<VkFramebuffer>( framebuffer ),
+                            reinterpret_cast<const VkAllocationCallbacks *>(
+                              static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Framebuffer                 framebuffer,
+                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyFramebuffer( m_device,
+                            static_cast<VkFramebuffer>( framebuffer ),
+                            reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Framebuffer   framebuffer,
+                                          Optional<const AllocationCallbacks> allocator,
+                                          Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyFramebuffer( m_device,
+                            static_cast<VkFramebuffer>( framebuffer ),
+                            reinterpret_cast<const VkAllocationCallbacks *>(
+                              static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::createRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo * pCreateInfo,
+                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks *  pAllocator,
+                              VULKAN_HPP_NAMESPACE::RenderPass *                 pRenderPass,
+                              Dispatch const &                                   d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkCreateRenderPass( m_device,
+                                                      reinterpret_cast<const VkRenderPassCreateInfo *>( pCreateInfo ),
+                                                      reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
+                                                      reinterpret_cast<VkRenderPass *>( pRenderPass ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::RenderPass>::type
+    Device::createRenderPass( const RenderPassCreateInfo &        createInfo,
+                              Optional<const AllocationCallbacks> allocator,
+                              Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::RenderPass renderPass;
+    Result                           result = static_cast<Result>(
+      d.vkCreateRenderPass( m_device,
+                            reinterpret_cast<const VkRenderPassCreateInfo *>( &createInfo ),
+                            reinterpret_cast<const VkAllocationCallbacks *>(
+                              static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                            reinterpret_cast<VkRenderPass *>( &renderPass ) ) );
+    return createResultValue( result, renderPass, VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPass" );
+  }
+
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type
+    Device::createRenderPassUnique( const RenderPassCreateInfo &        createInfo,
+                                    Optional<const AllocationCallbacks> allocator,
+                                    Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::RenderPass renderPass;
+    Result                           result = static_cast<Result>(
+      d.vkCreateRenderPass( m_device,
+                            reinterpret_cast<const VkRenderPassCreateInfo *>( &createInfo ),
+                            reinterpret_cast<const VkAllocationCallbacks *>(
+                              static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                            reinterpret_cast<VkRenderPass *>( &renderPass ) ) );
+    ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
+    return createResultValue<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>(
+      result, renderPass, VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPassUnique", deleter );
+  }
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyRenderPass( VULKAN_HPP_NAMESPACE::RenderPass                  renderPass,
+                                                    const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                                    Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyRenderPass( m_device,
+                           static_cast<VkRenderPass>( renderPass ),
+                           reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyRenderPass( VULKAN_HPP_NAMESPACE::RenderPass    renderPass,
+                                                    Optional<const AllocationCallbacks> allocator,
+                                                    Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyRenderPass( m_device,
+                           static_cast<VkRenderPass>( renderPass ),
+                           reinterpret_cast<const VkAllocationCallbacks *>(
+                             static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::RenderPass                  renderPass,
+                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyRenderPass( m_device,
+                           static_cast<VkRenderPass>( renderPass ),
+                           reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::RenderPass    renderPass,
+                                          Optional<const AllocationCallbacks> allocator,
+                                          Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyRenderPass( m_device,
+                           static_cast<VkRenderPass>( renderPass ),
+                           reinterpret_cast<const VkAllocationCallbacks *>(
+                             static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::getRenderAreaGranularity( VULKAN_HPP_NAMESPACE::RenderPass renderPass,
+                                                           VULKAN_HPP_NAMESPACE::Extent2D * pGranularity,
+                                                           Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkGetRenderAreaGranularity(
+      m_device, static_cast<VkRenderPass>( renderPass ), reinterpret_cast<VkExtent2D *>( pGranularity ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Extent2D
+                                         Device::getRenderAreaGranularity( VULKAN_HPP_NAMESPACE::RenderPass renderPass,
+                                      Dispatch const &                 d ) const VULKAN_HPP_NOEXCEPT
+  {
+    VULKAN_HPP_NAMESPACE::Extent2D granularity;
+    d.vkGetRenderAreaGranularity(
+      m_device, static_cast<VkRenderPass>( renderPass ), reinterpret_cast<VkExtent2D *>( &granularity ) );
+    return granularity;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::createCommandPool( const VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo * pCreateInfo,
+                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
+                               VULKAN_HPP_NAMESPACE::CommandPool *                 pCommandPool,
+                               Dispatch const &                                    d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkCreateCommandPool( m_device,
+                                                       reinterpret_cast<const VkCommandPoolCreateInfo *>( pCreateInfo ),
+                                                       reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
+                                                       reinterpret_cast<VkCommandPool *>( pCommandPool ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::CommandPool>::type
+    Device::createCommandPool( const CommandPoolCreateInfo &       createInfo,
+                               Optional<const AllocationCallbacks> allocator,
+                               Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::CommandPool commandPool;
+    Result                            result = static_cast<Result>(
+      d.vkCreateCommandPool( m_device,
+                             reinterpret_cast<const VkCommandPoolCreateInfo *>( &createInfo ),
+                             reinterpret_cast<const VkAllocationCallbacks *>(
+                               static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                             reinterpret_cast<VkCommandPool *>( &commandPool ) ) );
+    return createResultValue( result, commandPool, VULKAN_HPP_NAMESPACE_STRING "::Device::createCommandPool" );
+  }
+
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandPool, Dispatch>>::type
+    Device::createCommandPoolUnique( const CommandPoolCreateInfo &       createInfo,
+                                     Optional<const AllocationCallbacks> allocator,
+                                     Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::CommandPool commandPool;
+    Result                            result = static_cast<Result>(
+      d.vkCreateCommandPool( m_device,
+                             reinterpret_cast<const VkCommandPoolCreateInfo *>( &createInfo ),
+                             reinterpret_cast<const VkAllocationCallbacks *>(
+                               static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                             reinterpret_cast<VkCommandPool *>( &commandPool ) ) );
+    ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
+    return createResultValue<VULKAN_HPP_NAMESPACE::CommandPool, Dispatch>(
+      result, commandPool, VULKAN_HPP_NAMESPACE_STRING "::Device::createCommandPoolUnique", deleter );
+  }
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyCommandPool( VULKAN_HPP_NAMESPACE::CommandPool                 commandPool,
+                                                     const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                                     Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyCommandPool( m_device,
+                            static_cast<VkCommandPool>( commandPool ),
+                            reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyCommandPool( VULKAN_HPP_NAMESPACE::CommandPool   commandPool,
+                                                     Optional<const AllocationCallbacks> allocator,
+                                                     Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyCommandPool( m_device,
+                            static_cast<VkCommandPool>( commandPool ),
+                            reinterpret_cast<const VkAllocationCallbacks *>(
+                              static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::CommandPool                 commandPool,
+                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyCommandPool( m_device,
+                            static_cast<VkCommandPool>( commandPool ),
+                            reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::CommandPool   commandPool,
+                                          Optional<const AllocationCallbacks> allocator,
+                                          Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyCommandPool( m_device,
+                            static_cast<VkCommandPool>( commandPool ),
+                            reinterpret_cast<const VkAllocationCallbacks *>(
+                              static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::resetCommandPool( VULKAN_HPP_NAMESPACE::CommandPool           commandPool,
+                              VULKAN_HPP_NAMESPACE::CommandPoolResetFlags flags,
+                              Dispatch const &                            d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkResetCommandPool(
+      m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolResetFlags>( flags ) ) );
+  }
+#else
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<void>::type
+    Device::resetCommandPool( VULKAN_HPP_NAMESPACE::CommandPool commandPool,
+                              VULKAN_HPP_NAMESPACE::CommandPoolResetFlags flags,
+                              Dispatch const & d ) const
+  {
+    Result result = static_cast<Result>( d.vkResetCommandPool(
+      m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolResetFlags>( flags ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::resetCommandPool" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::allocateCommandBuffers( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo * pAllocateInfo,
+                                    VULKAN_HPP_NAMESPACE::CommandBuffer *                   pCommandBuffers,
+                                    Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkAllocateCommandBuffers( m_device,
+                                  reinterpret_cast<const VkCommandBufferAllocateInfo *>( pAllocateInfo ),
+                                  reinterpret_cast<VkCommandBuffer *>( pCommandBuffers ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename CommandBufferAllocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<std::vector<CommandBuffer, CommandBufferAllocator>>::type
+    Device::allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo, Dispatch const & d ) const
+  {
+    std::vector<CommandBuffer, CommandBufferAllocator> commandBuffers( allocateInfo.commandBufferCount );
+    Result                                             result = static_cast<Result>(
+      d.vkAllocateCommandBuffers( m_device,
+                                  reinterpret_cast<const VkCommandBufferAllocateInfo *>( &allocateInfo ),
+                                  reinterpret_cast<VkCommandBuffer *>( commandBuffers.data() ) ) );
+    return createResultValue( result, commandBuffers, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffers" );
+  }
+
+  template <typename CommandBufferAllocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, CommandBuffer>::value, int>::type>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<std::vector<CommandBuffer, CommandBufferAllocator>>::type
+    Device::allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo,
+                                    CommandBufferAllocator &          commandBufferAllocator,
+                                    Dispatch const &                  d ) const
+  {
+    std::vector<CommandBuffer, CommandBufferAllocator> commandBuffers( allocateInfo.commandBufferCount,
+                                                                       commandBufferAllocator );
+    Result                                             result = static_cast<Result>(
+      d.vkAllocateCommandBuffers( m_device,
+                                  reinterpret_cast<const VkCommandBufferAllocateInfo *>( &allocateInfo ),
+                                  reinterpret_cast<VkCommandBuffer *>( commandBuffers.data() ) ) );
+    return createResultValue( result, commandBuffers, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffers" );
+  }
+
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch, typename CommandBufferAllocator>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<std::vector<UniqueHandle<CommandBuffer, Dispatch>, CommandBufferAllocator>>::type
+    Device::allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo, Dispatch const & d ) const
+  {
+    std::vector<UniqueHandle<CommandBuffer, Dispatch>, CommandBufferAllocator> uniqueCommandBuffers;
+    std::vector<CommandBuffer> commandBuffers( allocateInfo.commandBufferCount );
+    Result                     result = static_cast<Result>(
+      d.vkAllocateCommandBuffers( m_device,
+                                  reinterpret_cast<const VkCommandBufferAllocateInfo *>( &allocateInfo ),
+                                  reinterpret_cast<VkCommandBuffer *>( commandBuffers.data() ) ) );
+    if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess )
+    {
+      uniqueCommandBuffers.reserve( allocateInfo.commandBufferCount );
+      PoolFree<Device, CommandPool, Dispatch> deleter( *this, allocateInfo.commandPool, d );
+      for ( size_t i = 0; i < allocateInfo.commandBufferCount; i++ )
+      {
+        uniqueCommandBuffers.push_back( UniqueHandle<CommandBuffer, Dispatch>( commandBuffers[i], deleter ) );
+      }
+    }
+    return createResultValue(
+      result, std::move( uniqueCommandBuffers ), VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffersUnique" );
+  }
+
+  template <typename Dispatch,
+            typename CommandBufferAllocator,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<CommandBuffer, Dispatch>>::value,
+                                    int>::type>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<std::vector<UniqueHandle<CommandBuffer, Dispatch>, CommandBufferAllocator>>::type
+    Device::allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo,
+                                          CommandBufferAllocator &          commandBufferAllocator,
+                                          Dispatch const &                  d ) const
+  {
+    std::vector<UniqueHandle<CommandBuffer, Dispatch>, CommandBufferAllocator> uniqueCommandBuffers(
+      commandBufferAllocator );
+    std::vector<CommandBuffer> commandBuffers( allocateInfo.commandBufferCount );
+    Result                     result = static_cast<Result>(
+      d.vkAllocateCommandBuffers( m_device,
+                                  reinterpret_cast<const VkCommandBufferAllocateInfo *>( &allocateInfo ),
+                                  reinterpret_cast<VkCommandBuffer *>( commandBuffers.data() ) ) );
+    if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess )
+    {
+      uniqueCommandBuffers.reserve( allocateInfo.commandBufferCount );
+      PoolFree<Device, CommandPool, Dispatch> deleter( *this, allocateInfo.commandPool, d );
+      for ( size_t i = 0; i < allocateInfo.commandBufferCount; i++ )
+      {
+        uniqueCommandBuffers.push_back( UniqueHandle<CommandBuffer, Dispatch>( commandBuffers[i], deleter ) );
+      }
+    }
+    return createResultValue(
+      result, std::move( uniqueCommandBuffers ), VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffersUnique" );
+  }
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::freeCommandBuffers( VULKAN_HPP_NAMESPACE::CommandPool           commandPool,
+                                                     uint32_t                                    commandBufferCount,
+                                                     const VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers,
+                                                     Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkFreeCommandBuffers( m_device,
+                            static_cast<VkCommandPool>( commandPool ),
+                            commandBufferCount,
+                            reinterpret_cast<const VkCommandBuffer *>( pCommandBuffers ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    Device::freeCommandBuffers( VULKAN_HPP_NAMESPACE::CommandPool                             commandPool,
+                                ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers,
+                                Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkFreeCommandBuffers( m_device,
+                            static_cast<VkCommandPool>( commandPool ),
+                            commandBuffers.size(),
+                            reinterpret_cast<const VkCommandBuffer *>( commandBuffers.data() ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::free( VULKAN_HPP_NAMESPACE::CommandPool           commandPool,
+                                       uint32_t                                    commandBufferCount,
+                                       const VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers,
+                                       Dispatch const &                            d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkFreeCommandBuffers( m_device,
+                            static_cast<VkCommandPool>( commandPool ),
+                            commandBufferCount,
+                            reinterpret_cast<const VkCommandBuffer *>( pCommandBuffers ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::free( VULKAN_HPP_NAMESPACE::CommandPool                             commandPool,
+                                       ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers,
+                                       Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkFreeCommandBuffers( m_device,
+                            static_cast<VkCommandPool>( commandPool ),
+                            commandBuffers.size(),
+                            reinterpret_cast<const VkCommandBuffer *>( commandBuffers.data() ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result CommandBuffer::begin(
+    const VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo * pBeginInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkBeginCommandBuffer( m_commandBuffer, reinterpret_cast<const VkCommandBufferBeginInfo *>( pBeginInfo ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
+    CommandBuffer::begin( const CommandBufferBeginInfo & beginInfo, Dispatch const & d ) const
+  {
+    Result result = static_cast<Result>(
+      d.vkBeginCommandBuffer( m_commandBuffer, reinterpret_cast<const VkCommandBufferBeginInfo *>( &beginInfo ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::begin" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result CommandBuffer::end( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkEndCommandBuffer( m_commandBuffer ) );
+  }
+#else
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
+    CommandBuffer::end( Dispatch const & d ) const
+  {
+    Result result = static_cast<Result>( d.vkEndCommandBuffer( m_commandBuffer ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::end" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result CommandBuffer::reset(
+    VULKAN_HPP_NAMESPACE::CommandBufferResetFlags flags, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkResetCommandBuffer( m_commandBuffer, static_cast<VkCommandBufferResetFlags>( flags ) ) );
+  }
+#else
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<void>::type
+    CommandBuffer::reset( VULKAN_HPP_NAMESPACE::CommandBufferResetFlags flags, Dispatch const & d ) const
+  {
+    Result result =
+      static_cast<Result>( d.vkResetCommandBuffer( m_commandBuffer, static_cast<VkCommandBufferResetFlags>( flags ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::reset" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::bindPipeline( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
+                                                      VULKAN_HPP_NAMESPACE::Pipeline          pipeline,
+                                                      Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdBindPipeline(
+      m_commandBuffer, static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipeline>( pipeline ) );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setViewport( uint32_t                               firstViewport,
+                                                     uint32_t                               viewportCount,
+                                                     const VULKAN_HPP_NAMESPACE::Viewport * pViewports,
+                                                     Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetViewport(
+      m_commandBuffer, firstViewport, viewportCount, reinterpret_cast<const VkViewport *>( pViewports ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setViewport( uint32_t firstViewport,
+                                                     ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports,
+                                                     Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetViewport(
+      m_commandBuffer, firstViewport, viewports.size(), reinterpret_cast<const VkViewport *>( viewports.data() ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setScissor( uint32_t                             firstScissor,
+                                                    uint32_t                             scissorCount,
+                                                    const VULKAN_HPP_NAMESPACE::Rect2D * pScissors,
+                                                    Dispatch const &                     d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetScissor( m_commandBuffer, firstScissor, scissorCount, reinterpret_cast<const VkRect2D *>( pScissors ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setScissor( uint32_t                                               firstScissor,
+                                                    ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors,
+                                                    Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetScissor(
+      m_commandBuffer, firstScissor, scissors.size(), reinterpret_cast<const VkRect2D *>( scissors.data() ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setLineWidth( float lineWidth, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetLineWidth( m_commandBuffer, lineWidth );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setDepthBias( float            depthBiasConstantFactor,
+                                                      float            depthBiasClamp,
+                                                      float            depthBiasSlopeFactor,
+                                                      Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetDepthBias( m_commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setBlendConstants( const float      blendConstants[4],
+                                                           Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetBlendConstants( m_commandBuffer, blendConstants );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setDepthBounds( float            minDepthBounds,
+                                                        float            maxDepthBounds,
+                                                        Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetDepthBounds( m_commandBuffer, minDepthBounds, maxDepthBounds );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setStencilCompareMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
+                                                               uint32_t                               compareMask,
+                                                               Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetStencilCompareMask( m_commandBuffer, static_cast<VkStencilFaceFlags>( faceMask ), compareMask );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setStencilWriteMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
+                                                             uint32_t                               writeMask,
+                                                             Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetStencilWriteMask( m_commandBuffer, static_cast<VkStencilFaceFlags>( faceMask ), writeMask );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setStencilReference( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
+                                                             uint32_t                               reference,
+                                                             Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetStencilReference( m_commandBuffer, static_cast<VkStencilFaceFlags>( faceMask ), reference );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorSets( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
+                                                            VULKAN_HPP_NAMESPACE::PipelineLayout    layout,
+                                                            uint32_t                                firstSet,
+                                                            uint32_t                                descriptorSetCount,
+                                                            const VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets,
+                                                            uint32_t         dynamicOffsetCount,
+                                                            const uint32_t * pDynamicOffsets,
+                                                            Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdBindDescriptorSets( m_commandBuffer,
+                               static_cast<VkPipelineBindPoint>( pipelineBindPoint ),
+                               static_cast<VkPipelineLayout>( layout ),
+                               firstSet,
+                               descriptorSetCount,
+                               reinterpret_cast<const VkDescriptorSet *>( pDescriptorSets ),
+                               dynamicOffsetCount,
+                               pDynamicOffsets );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    CommandBuffer::bindDescriptorSets( VULKAN_HPP_NAMESPACE::PipelineBindPoint                       pipelineBindPoint,
+                                       VULKAN_HPP_NAMESPACE::PipelineLayout                          layout,
+                                       uint32_t                                                      firstSet,
+                                       ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets,
+                                       ArrayProxy<const uint32_t> const &                            dynamicOffsets,
+                                       Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdBindDescriptorSets( m_commandBuffer,
+                               static_cast<VkPipelineBindPoint>( pipelineBindPoint ),
+                               static_cast<VkPipelineLayout>( layout ),
+                               firstSet,
+                               descriptorSets.size(),
+                               reinterpret_cast<const VkDescriptorSet *>( descriptorSets.data() ),
+                               dynamicOffsets.size(),
+                               dynamicOffsets.data() );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::bindIndexBuffer( VULKAN_HPP_NAMESPACE::Buffer     buffer,
+                                                         VULKAN_HPP_NAMESPACE::DeviceSize offset,
+                                                         VULKAN_HPP_NAMESPACE::IndexType  indexType,
+                                                         Dispatch const &                 d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdBindIndexBuffer( m_commandBuffer,
+                            static_cast<VkBuffer>( buffer ),
+                            static_cast<VkDeviceSize>( offset ),
+                            static_cast<VkIndexType>( indexType ) );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers( uint32_t                                 firstBinding,
+                                                           uint32_t                                 bindingCount,
+                                                           const VULKAN_HPP_NAMESPACE::Buffer *     pBuffers,
+                                                           const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets,
+                                                           Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdBindVertexBuffers( m_commandBuffer,
+                              firstBinding,
+                              bindingCount,
+                              reinterpret_cast<const VkBuffer *>( pBuffers ),
+                              reinterpret_cast<const VkDeviceSize *>( pOffsets ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    CommandBuffer::bindVertexBuffers( uint32_t                                                   firstBinding,
+                                      ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &     buffers,
+                                      ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,
+                                      Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
+  {
+#  ifdef VULKAN_HPP_NO_EXCEPTIONS
+    VULKAN_HPP_ASSERT( buffers.size() == offsets.size() );
+#  else
+    if ( buffers.size() != offsets.size() )
+    {
+      throw LogicError( VULKAN_HPP_NAMESPACE_STRING
+                        "::CommandBuffer::bindVertexBuffers: buffers.size() != offsets.size()" );
+    }
+#  endif /*VULKAN_HPP_NO_EXCEPTIONS*/
+
+    d.vkCmdBindVertexBuffers( m_commandBuffer,
+                              firstBinding,
+                              buffers.size(),
+                              reinterpret_cast<const VkBuffer *>( buffers.data() ),
+                              reinterpret_cast<const VkDeviceSize *>( offsets.data() ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::draw( uint32_t         vertexCount,
+                                              uint32_t         instanceCount,
+                                              uint32_t         firstVertex,
+                                              uint32_t         firstInstance,
+                                              Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdDraw( m_commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::drawIndexed( uint32_t         indexCount,
+                                                     uint32_t         instanceCount,
+                                                     uint32_t         firstIndex,
+                                                     int32_t          vertexOffset,
+                                                     uint32_t         firstInstance,
+                                                     Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdDrawIndexed( m_commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::drawIndirect( VULKAN_HPP_NAMESPACE::Buffer     buffer,
+                                                      VULKAN_HPP_NAMESPACE::DeviceSize offset,
+                                                      uint32_t                         drawCount,
+                                                      uint32_t                         stride,
+                                                      Dispatch const &                 d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdDrawIndirect(
+      m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), drawCount, stride );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirect( VULKAN_HPP_NAMESPACE::Buffer     buffer,
+                                                             VULKAN_HPP_NAMESPACE::DeviceSize offset,
+                                                             uint32_t                         drawCount,
+                                                             uint32_t                         stride,
+                                                             Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdDrawIndexedIndirect(
+      m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), drawCount, stride );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::dispatch( uint32_t         groupCountX,
+                                                  uint32_t         groupCountY,
+                                                  uint32_t         groupCountZ,
+                                                  Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdDispatch( m_commandBuffer, groupCountX, groupCountY, groupCountZ );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::dispatchIndirect( VULKAN_HPP_NAMESPACE::Buffer     buffer,
+                                                          VULKAN_HPP_NAMESPACE::DeviceSize offset,
+                                                          Dispatch const &                 d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdDispatchIndirect( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ) );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::copyBuffer( VULKAN_HPP_NAMESPACE::Buffer             srcBuffer,
+                                                    VULKAN_HPP_NAMESPACE::Buffer             dstBuffer,
+                                                    uint32_t                                 regionCount,
+                                                    const VULKAN_HPP_NAMESPACE::BufferCopy * pRegions,
+                                                    Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdCopyBuffer( m_commandBuffer,
+                       static_cast<VkBuffer>( srcBuffer ),
+                       static_cast<VkBuffer>( dstBuffer ),
+                       regionCount,
+                       reinterpret_cast<const VkBufferCopy *>( pRegions ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::copyBuffer( VULKAN_HPP_NAMESPACE::Buffer srcBuffer,
+                                                    VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
+                                                    ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferCopy> const & regions,
+                                                    Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdCopyBuffer( m_commandBuffer,
+                       static_cast<VkBuffer>( srcBuffer ),
+                       static_cast<VkBuffer>( dstBuffer ),
+                       regions.size(),
+                       reinterpret_cast<const VkBufferCopy *>( regions.data() ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::copyImage( VULKAN_HPP_NAMESPACE::Image             srcImage,
+                                                   VULKAN_HPP_NAMESPACE::ImageLayout       srcImageLayout,
+                                                   VULKAN_HPP_NAMESPACE::Image             dstImage,
+                                                   VULKAN_HPP_NAMESPACE::ImageLayout       dstImageLayout,
+                                                   uint32_t                                regionCount,
+                                                   const VULKAN_HPP_NAMESPACE::ImageCopy * pRegions,
+                                                   Dispatch const &                        d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdCopyImage( m_commandBuffer,
+                      static_cast<VkImage>( srcImage ),
+                      static_cast<VkImageLayout>( srcImageLayout ),
+                      static_cast<VkImage>( dstImage ),
+                      static_cast<VkImageLayout>( dstImageLayout ),
+                      regionCount,
+                      reinterpret_cast<const VkImageCopy *>( pRegions ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::copyImage( VULKAN_HPP_NAMESPACE::Image       srcImage,
+                                                   VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout,
+                                                   VULKAN_HPP_NAMESPACE::Image       dstImage,
+                                                   VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,
+                                                   ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageCopy> const & regions,
+                                                   Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdCopyImage( m_commandBuffer,
+                      static_cast<VkImage>( srcImage ),
+                      static_cast<VkImageLayout>( srcImageLayout ),
+                      static_cast<VkImage>( dstImage ),
+                      static_cast<VkImageLayout>( dstImageLayout ),
+                      regions.size(),
+                      reinterpret_cast<const VkImageCopy *>( regions.data() ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::blitImage( VULKAN_HPP_NAMESPACE::Image             srcImage,
+                                                   VULKAN_HPP_NAMESPACE::ImageLayout       srcImageLayout,
+                                                   VULKAN_HPP_NAMESPACE::Image             dstImage,
+                                                   VULKAN_HPP_NAMESPACE::ImageLayout       dstImageLayout,
+                                                   uint32_t                                regionCount,
+                                                   const VULKAN_HPP_NAMESPACE::ImageBlit * pRegions,
+                                                   VULKAN_HPP_NAMESPACE::Filter            filter,
+                                                   Dispatch const &                        d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdBlitImage( m_commandBuffer,
+                      static_cast<VkImage>( srcImage ),
+                      static_cast<VkImageLayout>( srcImageLayout ),
+                      static_cast<VkImage>( dstImage ),
+                      static_cast<VkImageLayout>( dstImageLayout ),
+                      regionCount,
+                      reinterpret_cast<const VkImageBlit *>( pRegions ),
+                      static_cast<VkFilter>( filter ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::blitImage( VULKAN_HPP_NAMESPACE::Image       srcImage,
+                                                   VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout,
+                                                   VULKAN_HPP_NAMESPACE::Image       dstImage,
+                                                   VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,
+                                                   ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageBlit> const & regions,
+                                                   VULKAN_HPP_NAMESPACE::Filter                              filter,
+                                                   Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdBlitImage( m_commandBuffer,
+                      static_cast<VkImage>( srcImage ),
+                      static_cast<VkImageLayout>( srcImageLayout ),
+                      static_cast<VkImage>( dstImage ),
+                      static_cast<VkImageLayout>( dstImageLayout ),
+                      regions.size(),
+                      reinterpret_cast<const VkImageBlit *>( regions.data() ),
+                      static_cast<VkFilter>( filter ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage( VULKAN_HPP_NAMESPACE::Buffer                  srcBuffer,
+                                                           VULKAN_HPP_NAMESPACE::Image                   dstImage,
+                                                           VULKAN_HPP_NAMESPACE::ImageLayout             dstImageLayout,
+                                                           uint32_t                                      regionCount,
+                                                           const VULKAN_HPP_NAMESPACE::BufferImageCopy * pRegions,
+                                                           Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdCopyBufferToImage( m_commandBuffer,
+                              static_cast<VkBuffer>( srcBuffer ),
+                              static_cast<VkImage>( dstImage ),
+                              static_cast<VkImageLayout>( dstImageLayout ),
+                              regionCount,
+                              reinterpret_cast<const VkBufferImageCopy *>( pRegions ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    CommandBuffer::copyBufferToImage( VULKAN_HPP_NAMESPACE::Buffer                                    srcBuffer,
+                                      VULKAN_HPP_NAMESPACE::Image                                     dstImage,
+                                      VULKAN_HPP_NAMESPACE::ImageLayout                               dstImageLayout,
+                                      ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions,
+                                      Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdCopyBufferToImage( m_commandBuffer,
+                              static_cast<VkBuffer>( srcBuffer ),
+                              static_cast<VkImage>( dstImage ),
+                              static_cast<VkImageLayout>( dstImageLayout ),
+                              regions.size(),
+                              reinterpret_cast<const VkBufferImageCopy *>( regions.data() ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer( VULKAN_HPP_NAMESPACE::Image                   srcImage,
+                                                           VULKAN_HPP_NAMESPACE::ImageLayout             srcImageLayout,
+                                                           VULKAN_HPP_NAMESPACE::Buffer                  dstBuffer,
+                                                           uint32_t                                      regionCount,
+                                                           const VULKAN_HPP_NAMESPACE::BufferImageCopy * pRegions,
+                                                           Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdCopyImageToBuffer( m_commandBuffer,
+                              static_cast<VkImage>( srcImage ),
+                              static_cast<VkImageLayout>( srcImageLayout ),
+                              static_cast<VkBuffer>( dstBuffer ),
+                              regionCount,
+                              reinterpret_cast<const VkBufferImageCopy *>( pRegions ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    CommandBuffer::copyImageToBuffer( VULKAN_HPP_NAMESPACE::Image                                     srcImage,
+                                      VULKAN_HPP_NAMESPACE::ImageLayout                               srcImageLayout,
+                                      VULKAN_HPP_NAMESPACE::Buffer                                    dstBuffer,
+                                      ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions,
+                                      Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdCopyImageToBuffer( m_commandBuffer,
+                              static_cast<VkImage>( srcImage ),
+                              static_cast<VkImageLayout>( srcImageLayout ),
+                              static_cast<VkBuffer>( dstBuffer ),
+                              regions.size(),
+                              reinterpret_cast<const VkBufferImageCopy *>( regions.data() ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::updateBuffer( VULKAN_HPP_NAMESPACE::Buffer     dstBuffer,
+                                                      VULKAN_HPP_NAMESPACE::DeviceSize dstOffset,
+                                                      VULKAN_HPP_NAMESPACE::DeviceSize dataSize,
+                                                      const void *                     pData,
+                                                      Dispatch const &                 d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdUpdateBuffer( m_commandBuffer,
+                         static_cast<VkBuffer>( dstBuffer ),
+                         static_cast<VkDeviceSize>( dstOffset ),
+                         static_cast<VkDeviceSize>( dataSize ),
+                         pData );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename T, typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::updateBuffer( VULKAN_HPP_NAMESPACE::Buffer     dstBuffer,
+                                                      VULKAN_HPP_NAMESPACE::DeviceSize dstOffset,
+                                                      ArrayProxy<const T> const &      data,
+                                                      Dispatch const &                 d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdUpdateBuffer( m_commandBuffer,
+                         static_cast<VkBuffer>( dstBuffer ),
+                         static_cast<VkDeviceSize>( dstOffset ),
+                         data.size() * sizeof( T ),
+                         reinterpret_cast<const void *>( data.data() ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::fillBuffer( VULKAN_HPP_NAMESPACE::Buffer     dstBuffer,
+                                                    VULKAN_HPP_NAMESPACE::DeviceSize dstOffset,
+                                                    VULKAN_HPP_NAMESPACE::DeviceSize size,
+                                                    uint32_t                         data,
+                                                    Dispatch const &                 d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdFillBuffer( m_commandBuffer,
+                       static_cast<VkBuffer>( dstBuffer ),
+                       static_cast<VkDeviceSize>( dstOffset ),
+                       static_cast<VkDeviceSize>( size ),
+                       data );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::clearColorImage( VULKAN_HPP_NAMESPACE::Image                   image,
+                                                         VULKAN_HPP_NAMESPACE::ImageLayout             imageLayout,
+                                                         const VULKAN_HPP_NAMESPACE::ClearColorValue * pColor,
+                                                         uint32_t                                      rangeCount,
+                                                         const VULKAN_HPP_NAMESPACE::ImageSubresourceRange * pRanges,
+                                                         Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdClearColorImage( m_commandBuffer,
+                            static_cast<VkImage>( image ),
+                            static_cast<VkImageLayout>( imageLayout ),
+                            reinterpret_cast<const VkClearColorValue *>( pColor ),
+                            rangeCount,
+                            reinterpret_cast<const VkImageSubresourceRange *>( pRanges ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    CommandBuffer::clearColorImage( VULKAN_HPP_NAMESPACE::Image                                           image,
+                                    VULKAN_HPP_NAMESPACE::ImageLayout                                     imageLayout,
+                                    const ClearColorValue &                                               color,
+                                    ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceRange> const & ranges,
+                                    Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdClearColorImage( m_commandBuffer,
+                            static_cast<VkImage>( image ),
+                            static_cast<VkImageLayout>( imageLayout ),
+                            reinterpret_cast<const VkClearColorValue *>( &color ),
+                            ranges.size(),
+                            reinterpret_cast<const VkImageSubresourceRange *>( ranges.data() ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    CommandBuffer::clearDepthStencilImage( VULKAN_HPP_NAMESPACE::Image                          image,
+                                           VULKAN_HPP_NAMESPACE::ImageLayout                    imageLayout,
+                                           const VULKAN_HPP_NAMESPACE::ClearDepthStencilValue * pDepthStencil,
+                                           uint32_t                                             rangeCount,
+                                           const VULKAN_HPP_NAMESPACE::ImageSubresourceRange *  pRanges,
+                                           Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdClearDepthStencilImage( m_commandBuffer,
+                                   static_cast<VkImage>( image ),
+                                   static_cast<VkImageLayout>( imageLayout ),
+                                   reinterpret_cast<const VkClearDepthStencilValue *>( pDepthStencil ),
+                                   rangeCount,
+                                   reinterpret_cast<const VkImageSubresourceRange *>( pRanges ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    CommandBuffer::clearDepthStencilImage( VULKAN_HPP_NAMESPACE::Image       image,
+                                           VULKAN_HPP_NAMESPACE::ImageLayout imageLayout,
+                                           const ClearDepthStencilValue &    depthStencil,
+                                           ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceRange> const & ranges,
+                                           Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdClearDepthStencilImage( m_commandBuffer,
+                                   static_cast<VkImage>( image ),
+                                   static_cast<VkImageLayout>( imageLayout ),
+                                   reinterpret_cast<const VkClearDepthStencilValue *>( &depthStencil ),
+                                   ranges.size(),
+                                   reinterpret_cast<const VkImageSubresourceRange *>( ranges.data() ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::clearAttachments( uint32_t                                      attachmentCount,
+                                                          const VULKAN_HPP_NAMESPACE::ClearAttachment * pAttachments,
+                                                          uint32_t                                      rectCount,
+                                                          const VULKAN_HPP_NAMESPACE::ClearRect *       pRects,
+                                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdClearAttachments( m_commandBuffer,
+                             attachmentCount,
+                             reinterpret_cast<const VkClearAttachment *>( pAttachments ),
+                             rectCount,
+                             reinterpret_cast<const VkClearRect *>( pRects ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    CommandBuffer::clearAttachments( ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearAttachment> const & attachments,
+                                     ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearRect> const &       rects,
+                                     Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdClearAttachments( m_commandBuffer,
+                             attachments.size(),
+                             reinterpret_cast<const VkClearAttachment *>( attachments.data() ),
+                             rects.size(),
+                             reinterpret_cast<const VkClearRect *>( rects.data() ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::resolveImage( VULKAN_HPP_NAMESPACE::Image                srcImage,
+                                                      VULKAN_HPP_NAMESPACE::ImageLayout          srcImageLayout,
+                                                      VULKAN_HPP_NAMESPACE::Image                dstImage,
+                                                      VULKAN_HPP_NAMESPACE::ImageLayout          dstImageLayout,
+                                                      uint32_t                                   regionCount,
+                                                      const VULKAN_HPP_NAMESPACE::ImageResolve * pRegions,
+                                                      Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdResolveImage( m_commandBuffer,
+                         static_cast<VkImage>( srcImage ),
+                         static_cast<VkImageLayout>( srcImageLayout ),
+                         static_cast<VkImage>( dstImage ),
+                         static_cast<VkImageLayout>( dstImageLayout ),
+                         regionCount,
+                         reinterpret_cast<const VkImageResolve *>( pRegions ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    CommandBuffer::resolveImage( VULKAN_HPP_NAMESPACE::Image                                  srcImage,
+                                 VULKAN_HPP_NAMESPACE::ImageLayout                            srcImageLayout,
+                                 VULKAN_HPP_NAMESPACE::Image                                  dstImage,
+                                 VULKAN_HPP_NAMESPACE::ImageLayout                            dstImageLayout,
+                                 ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageResolve> const & regions,
+                                 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdResolveImage( m_commandBuffer,
+                         static_cast<VkImage>( srcImage ),
+                         static_cast<VkImageLayout>( srcImageLayout ),
+                         static_cast<VkImage>( dstImage ),
+                         static_cast<VkImageLayout>( dstImageLayout ),
+                         regions.size(),
+                         reinterpret_cast<const VkImageResolve *>( regions.data() ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setEvent( VULKAN_HPP_NAMESPACE::Event              event,
+                                                  VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask,
+                                                  Dispatch const &                         d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetEvent( m_commandBuffer, static_cast<VkEvent>( event ), static_cast<VkPipelineStageFlags>( stageMask ) );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::resetEvent( VULKAN_HPP_NAMESPACE::Event              event,
+                                                    VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask,
+                                                    Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdResetEvent( m_commandBuffer, static_cast<VkEvent>( event ), static_cast<VkPipelineStageFlags>( stageMask ) );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    CommandBuffer::waitEvents( uint32_t                                          eventCount,
+                               const VULKAN_HPP_NAMESPACE::Event *               pEvents,
+                               VULKAN_HPP_NAMESPACE::PipelineStageFlags          srcStageMask,
+                               VULKAN_HPP_NAMESPACE::PipelineStageFlags          dstStageMask,
+                               uint32_t                                          memoryBarrierCount,
+                               const VULKAN_HPP_NAMESPACE::MemoryBarrier *       pMemoryBarriers,
+                               uint32_t                                          bufferMemoryBarrierCount,
+                               const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier * pBufferMemoryBarriers,
+                               uint32_t                                          imageMemoryBarrierCount,
+                               const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier *  pImageMemoryBarriers,
+                               Dispatch const &                                  d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdWaitEvents( m_commandBuffer,
+                       eventCount,
+                       reinterpret_cast<const VkEvent *>( pEvents ),
+                       static_cast<VkPipelineStageFlags>( srcStageMask ),
+                       static_cast<VkPipelineStageFlags>( dstStageMask ),
+                       memoryBarrierCount,
+                       reinterpret_cast<const VkMemoryBarrier *>( pMemoryBarriers ),
+                       bufferMemoryBarrierCount,
+                       reinterpret_cast<const VkBufferMemoryBarrier *>( pBufferMemoryBarriers ),
+                       imageMemoryBarrierCount,
+                       reinterpret_cast<const VkImageMemoryBarrier *>( pImageMemoryBarriers ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    CommandBuffer::waitEvents( ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const &               events,
+                               VULKAN_HPP_NAMESPACE::PipelineStageFlags                            srcStageMask,
+                               VULKAN_HPP_NAMESPACE::PipelineStageFlags                            dstStageMask,
+                               ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const &       memoryBarriers,
+                               ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const & bufferMemoryBarriers,
+                               ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const &  imageMemoryBarriers,
+                               Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdWaitEvents( m_commandBuffer,
+                       events.size(),
+                       reinterpret_cast<const VkEvent *>( events.data() ),
+                       static_cast<VkPipelineStageFlags>( srcStageMask ),
+                       static_cast<VkPipelineStageFlags>( dstStageMask ),
+                       memoryBarriers.size(),
+                       reinterpret_cast<const VkMemoryBarrier *>( memoryBarriers.data() ),
+                       bufferMemoryBarriers.size(),
+                       reinterpret_cast<const VkBufferMemoryBarrier *>( bufferMemoryBarriers.data() ),
+                       imageMemoryBarriers.size(),
+                       reinterpret_cast<const VkImageMemoryBarrier *>( imageMemoryBarriers.data() ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    CommandBuffer::pipelineBarrier( VULKAN_HPP_NAMESPACE::PipelineStageFlags          srcStageMask,
+                                    VULKAN_HPP_NAMESPACE::PipelineStageFlags          dstStageMask,
+                                    VULKAN_HPP_NAMESPACE::DependencyFlags             dependencyFlags,
+                                    uint32_t                                          memoryBarrierCount,
+                                    const VULKAN_HPP_NAMESPACE::MemoryBarrier *       pMemoryBarriers,
+                                    uint32_t                                          bufferMemoryBarrierCount,
+                                    const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier * pBufferMemoryBarriers,
+                                    uint32_t                                          imageMemoryBarrierCount,
+                                    const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier *  pImageMemoryBarriers,
+                                    Dispatch const &                                  d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdPipelineBarrier( m_commandBuffer,
+                            static_cast<VkPipelineStageFlags>( srcStageMask ),
+                            static_cast<VkPipelineStageFlags>( dstStageMask ),
+                            static_cast<VkDependencyFlags>( dependencyFlags ),
+                            memoryBarrierCount,
+                            reinterpret_cast<const VkMemoryBarrier *>( pMemoryBarriers ),
+                            bufferMemoryBarrierCount,
+                            reinterpret_cast<const VkBufferMemoryBarrier *>( pBufferMemoryBarriers ),
+                            imageMemoryBarrierCount,
+                            reinterpret_cast<const VkImageMemoryBarrier *>( pImageMemoryBarriers ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier(
+    VULKAN_HPP_NAMESPACE::PipelineStageFlags                            srcStageMask,
+    VULKAN_HPP_NAMESPACE::PipelineStageFlags                            dstStageMask,
+    VULKAN_HPP_NAMESPACE::DependencyFlags                               dependencyFlags,
+    ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const &       memoryBarriers,
+    ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const & bufferMemoryBarriers,
+    ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const &  imageMemoryBarriers,
+    Dispatch const &                                                    d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdPipelineBarrier( m_commandBuffer,
+                            static_cast<VkPipelineStageFlags>( srcStageMask ),
+                            static_cast<VkPipelineStageFlags>( dstStageMask ),
+                            static_cast<VkDependencyFlags>( dependencyFlags ),
+                            memoryBarriers.size(),
+                            reinterpret_cast<const VkMemoryBarrier *>( memoryBarriers.data() ),
+                            bufferMemoryBarriers.size(),
+                            reinterpret_cast<const VkBufferMemoryBarrier *>( bufferMemoryBarriers.data() ),
+                            imageMemoryBarriers.size(),
+                            reinterpret_cast<const VkImageMemoryBarrier *>( imageMemoryBarriers.data() ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::beginQuery( VULKAN_HPP_NAMESPACE::QueryPool         queryPool,
+                                                    uint32_t                                query,
+                                                    VULKAN_HPP_NAMESPACE::QueryControlFlags flags,
+                                                    Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdBeginQuery(
+      m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query, static_cast<VkQueryControlFlags>( flags ) );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::endQuery( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
+                                                  uint32_t                        query,
+                                                  Dispatch const &                d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdEndQuery( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::resetQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
+                                                        uint32_t                        firstQuery,
+                                                        uint32_t                        queryCount,
+                                                        Dispatch const &                d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdResetQueryPool( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::writeTimestamp( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage,
+                                                        VULKAN_HPP_NAMESPACE::QueryPool             queryPool,
+                                                        uint32_t                                    query,
+                                                        Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdWriteTimestamp( m_commandBuffer,
+                           static_cast<VkPipelineStageFlagBits>( pipelineStage ),
+                           static_cast<VkQueryPool>( queryPool ),
+                           query );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::copyQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool        queryPool,
+                                                              uint32_t                               firstQuery,
+                                                              uint32_t                               queryCount,
+                                                              VULKAN_HPP_NAMESPACE::Buffer           dstBuffer,
+                                                              VULKAN_HPP_NAMESPACE::DeviceSize       dstOffset,
+                                                              VULKAN_HPP_NAMESPACE::DeviceSize       stride,
+                                                              VULKAN_HPP_NAMESPACE::QueryResultFlags flags,
+                                                              Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdCopyQueryPoolResults( m_commandBuffer,
+                                 static_cast<VkQueryPool>( queryPool ),
+                                 firstQuery,
+                                 queryCount,
+                                 static_cast<VkBuffer>( dstBuffer ),
+                                 static_cast<VkDeviceSize>( dstOffset ),
+                                 static_cast<VkDeviceSize>( stride ),
+                                 static_cast<VkQueryResultFlags>( flags ) );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout   layout,
+                                                       VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags,
+                                                       uint32_t                               offset,
+                                                       uint32_t                               size,
+                                                       const void *                           pValues,
+                                                       Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdPushConstants( m_commandBuffer,
+                          static_cast<VkPipelineLayout>( layout ),
+                          static_cast<VkShaderStageFlags>( stageFlags ),
+                          offset,
+                          size,
+                          pValues );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename T, typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout   layout,
+                                                       VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags,
+                                                       uint32_t                               offset,
+                                                       ArrayProxy<const T> const &            values,
+                                                       Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdPushConstants( m_commandBuffer,
+                          static_cast<VkPipelineLayout>( layout ),
+                          static_cast<VkShaderStageFlags>( stageFlags ),
+                          offset,
+                          values.size() * sizeof( T ),
+                          reinterpret_cast<const void *>( values.data() ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    CommandBuffer::beginRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo * pRenderPassBegin,
+                                    VULKAN_HPP_NAMESPACE::SubpassContents             contents,
+                                    Dispatch const &                                  d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdBeginRenderPass( m_commandBuffer,
+                            reinterpret_cast<const VkRenderPassBeginInfo *>( pRenderPassBegin ),
+                            static_cast<VkSubpassContents>( contents ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass( const RenderPassBeginInfo &           renderPassBegin,
+                                                         VULKAN_HPP_NAMESPACE::SubpassContents contents,
+                                                         Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdBeginRenderPass( m_commandBuffer,
+                            reinterpret_cast<const VkRenderPassBeginInfo *>( &renderPassBegin ),
+                            static_cast<VkSubpassContents>( contents ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::nextSubpass( VULKAN_HPP_NAMESPACE::SubpassContents contents,
+                                                     Dispatch const &                      d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdNextSubpass( m_commandBuffer, static_cast<VkSubpassContents>( contents ) );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::endRenderPass( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdEndRenderPass( m_commandBuffer );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::executeCommands( uint32_t                                    commandBufferCount,
+                                                         const VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers,
+                                                         Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdExecuteCommands(
+      m_commandBuffer, commandBufferCount, reinterpret_cast<const VkCommandBuffer *>( pCommandBuffers ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    CommandBuffer::executeCommands( ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers,
+                                    Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdExecuteCommands(
+      m_commandBuffer, commandBuffers.size(), reinterpret_cast<const VkCommandBuffer *>( commandBuffers.data() ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  //=== VK_VERSION_1_1 ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result enumerateInstanceVersion( uint32_t *       pApiVersion,
+                                                                          Dispatch const & d ) VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkEnumerateInstanceVersion( pApiVersion ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<uint32_t>::type enumerateInstanceVersion( Dispatch const & d )
+  {
+    uint32_t apiVersion;
+    Result   result = static_cast<Result>( d.vkEnumerateInstanceVersion( &apiVersion ) );
+    return createResultValue( result, apiVersion, VULKAN_HPP_NAMESPACE_STRING "::enumerateInstanceVersion" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::bindBufferMemory2( uint32_t                                           bindInfoCount,
+                               const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo * pBindInfos,
+                               Dispatch const &                                   d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkBindBufferMemory2(
+      m_device, bindInfoCount, reinterpret_cast<const VkBindBufferMemoryInfo *>( pBindInfos ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
+    Device::bindBufferMemory2( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos,
+                               Dispatch const &                                                     d ) const
+  {
+    Result result = static_cast<Result>( d.vkBindBufferMemory2(
+      m_device, bindInfos.size(), reinterpret_cast<const VkBindBufferMemoryInfo *>( bindInfos.data() ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindBufferMemory2" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::bindImageMemory2( uint32_t                                          bindInfoCount,
+                              const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo * pBindInfos,
+                              Dispatch const &                                  d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkBindImageMemory2( m_device, bindInfoCount, reinterpret_cast<const VkBindImageMemoryInfo *>( pBindInfos ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
+    Device::bindImageMemory2( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos,
+                              Dispatch const &                                                    d ) const
+  {
+    Result result = static_cast<Result>( d.vkBindImageMemory2(
+      m_device, bindInfos.size(), reinterpret_cast<const VkBindImageMemoryInfo *>( bindInfos.data() ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindImageMemory2" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    Device::getGroupPeerMemoryFeatures( uint32_t                                       heapIndex,
+                                        uint32_t                                       localDeviceIndex,
+                                        uint32_t                                       remoteDeviceIndex,
+                                        VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags * pPeerMemoryFeatures,
+                                        Dispatch const &                               d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkGetDeviceGroupPeerMemoryFeatures( m_device,
+                                          heapIndex,
+                                          localDeviceIndex,
+                                          remoteDeviceIndex,
+                                          reinterpret_cast<VkPeerMemoryFeatureFlags *>( pPeerMemoryFeatures ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags
+                                         Device::getGroupPeerMemoryFeatures( uint32_t         heapIndex,
+                                        uint32_t         localDeviceIndex,
+                                        uint32_t         remoteDeviceIndex,
+                                        Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags peerMemoryFeatures;
+    d.vkGetDeviceGroupPeerMemoryFeatures( m_device,
+                                          heapIndex,
+                                          localDeviceIndex,
+                                          remoteDeviceIndex,
+                                          reinterpret_cast<VkPeerMemoryFeatureFlags *>( &peerMemoryFeatures ) );
+    return peerMemoryFeatures;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setDeviceMask( uint32_t         deviceMask,
+                                                       Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetDeviceMask( m_commandBuffer, deviceMask );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::dispatchBase( uint32_t         baseGroupX,
+                                                      uint32_t         baseGroupY,
+                                                      uint32_t         baseGroupZ,
+                                                      uint32_t         groupCountX,
+                                                      uint32_t         groupCountY,
+                                                      uint32_t         groupCountZ,
+                                                      Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdDispatchBase( m_commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::enumeratePhysicalDeviceGroups(
+    uint32_t *                                            pPhysicalDeviceGroupCount,
+    VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties,
+    Dispatch const &                                      d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkEnumeratePhysicalDeviceGroups(
+      m_instance,
+      pPhysicalDeviceGroupCount,
+      reinterpret_cast<VkPhysicalDeviceGroupProperties *>( pPhysicalDeviceGroupProperties ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename PhysicalDeviceGroupPropertiesAllocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
+    typename ResultValueType<std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
+    Instance::enumeratePhysicalDeviceGroups( Dispatch const & d ) const
+  {
+    std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator> physicalDeviceGroupProperties;
+    uint32_t                                                                           physicalDeviceGroupCount;
+    Result                                                                             result;
+    do
+    {
+      result =
+        static_cast<Result>( d.vkEnumeratePhysicalDeviceGroups( m_instance, &physicalDeviceGroupCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && physicalDeviceGroupCount )
+      {
+        physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
+        result = static_cast<Result>( d.vkEnumeratePhysicalDeviceGroups(
+          m_instance,
+          &physicalDeviceGroupCount,
+          reinterpret_cast<VkPhysicalDeviceGroupProperties *>( physicalDeviceGroupProperties.data() ) ) );
+        VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( physicalDeviceGroupCount < physicalDeviceGroupProperties.size() ) )
+    {
+      physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
+    }
+    return createResultValue(
+      result, physicalDeviceGroupProperties, VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDeviceGroups" );
+  }
+
+  template <
+    typename PhysicalDeviceGroupPropertiesAllocator,
+    typename Dispatch,
+    typename B,
+    typename std::enable_if<std::is_same<typename B::value_type, PhysicalDeviceGroupProperties>::value, int>::type>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
+    typename ResultValueType<std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
+    Instance::enumeratePhysicalDeviceGroups(
+      PhysicalDeviceGroupPropertiesAllocator & physicalDeviceGroupPropertiesAllocator, Dispatch const & d ) const
+  {
+    std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator> physicalDeviceGroupProperties(
+      physicalDeviceGroupPropertiesAllocator );
+    uint32_t physicalDeviceGroupCount;
+    Result   result;
+    do
+    {
+      result =
+        static_cast<Result>( d.vkEnumeratePhysicalDeviceGroups( m_instance, &physicalDeviceGroupCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && physicalDeviceGroupCount )
+      {
+        physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
+        result = static_cast<Result>( d.vkEnumeratePhysicalDeviceGroups(
+          m_instance,
+          &physicalDeviceGroupCount,
+          reinterpret_cast<VkPhysicalDeviceGroupProperties *>( physicalDeviceGroupProperties.data() ) ) );
+        VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( physicalDeviceGroupCount < physicalDeviceGroupProperties.size() ) )
+    {
+      physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
+    }
+    return createResultValue(
+      result, physicalDeviceGroupProperties, VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDeviceGroups" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    Device::getImageMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 * pInfo,
+                                         VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                pMemoryRequirements,
+                                         Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkGetImageMemoryRequirements2( m_device,
+                                     reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( pInfo ),
+                                     reinterpret_cast<VkMemoryRequirements2 *>( pMemoryRequirements ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2
+                                         Device::getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info,
+                                         Dispatch const &                     d ) const VULKAN_HPP_NOEXCEPT
+  {
+    VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements;
+    d.vkGetImageMemoryRequirements2( m_device,
+                                     reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( &info ),
+                                     reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
+    return memoryRequirements;
+  }
+
+  template <typename X, typename Y, typename... Z, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
+                                         Device::getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info,
+                                         Dispatch const &                     d ) const VULKAN_HPP_NOEXCEPT
+  {
+    StructureChain<X, Y, Z...>                  structureChain;
+    VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements =
+      structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>();
+    d.vkGetImageMemoryRequirements2( m_device,
+                                     reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( &info ),
+                                     reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
+    return structureChain;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    Device::getBufferMemoryRequirements2( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 * pInfo,
+                                          VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements,
+                                          Dispatch const &                            d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkGetBufferMemoryRequirements2( m_device,
+                                      reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( pInfo ),
+                                      reinterpret_cast<VkMemoryRequirements2 *>( pMemoryRequirements ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2
+    Device::getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info,
+                                          Dispatch const &                      d ) const VULKAN_HPP_NOEXCEPT
+  {
+    VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements;
+    d.vkGetBufferMemoryRequirements2( m_device,
+                                      reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( &info ),
+                                      reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
+    return memoryRequirements;
+  }
+
+  template <typename X, typename Y, typename... Z, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
+    Device::getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info,
+                                          Dispatch const &                      d ) const VULKAN_HPP_NOEXCEPT
+  {
+    StructureChain<X, Y, Z...>                  structureChain;
+    VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements =
+      structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>();
+    d.vkGetBufferMemoryRequirements2( m_device,
+                                      reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( &info ),
+                                      reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
+    return structureChain;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements2(
+    const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 * pInfo,
+    uint32_t *                                                       pSparseMemoryRequirementCount,
+    VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 *           pSparseMemoryRequirements,
+    Dispatch const &                                                 d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkGetImageSparseMemoryRequirements2(
+      m_device,
+      reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( pInfo ),
+      pSparseMemoryRequirementCount,
+      reinterpret_cast<VkSparseImageMemoryRequirements2 *>( pSparseMemoryRequirements ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename SparseImageMemoryRequirements2Allocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD
+    VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
+                      Device::getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info,
+                                               Dispatch const &                           d ) const
+  {
+    std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> sparseMemoryRequirements;
+    uint32_t                                                                             sparseMemoryRequirementCount;
+    d.vkGetImageSparseMemoryRequirements2( m_device,
+                                           reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ),
+                                           &sparseMemoryRequirementCount,
+                                           nullptr );
+    sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
+    d.vkGetImageSparseMemoryRequirements2(
+      m_device,
+      reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ),
+      &sparseMemoryRequirementCount,
+      reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) );
+    VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() );
+    return sparseMemoryRequirements;
+  }
+
+  template <
+    typename SparseImageMemoryRequirements2Allocator,
+    typename Dispatch,
+    typename B,
+    typename std::enable_if<std::is_same<typename B::value_type, SparseImageMemoryRequirements2>::value, int>::type>
+  VULKAN_HPP_NODISCARD
+    VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
+                      Device::getImageSparseMemoryRequirements2(
+      const ImageSparseMemoryRequirementsInfo2 & info,
+      SparseImageMemoryRequirements2Allocator &  sparseImageMemoryRequirements2Allocator,
+      Dispatch const &                           d ) const
+  {
+    std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> sparseMemoryRequirements(
+      sparseImageMemoryRequirements2Allocator );
+    uint32_t sparseMemoryRequirementCount;
+    d.vkGetImageSparseMemoryRequirements2( m_device,
+                                           reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ),
+                                           &sparseMemoryRequirementCount,
+                                           nullptr );
+    sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
+    d.vkGetImageSparseMemoryRequirements2(
+      m_device,
+      reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ),
+      &sparseMemoryRequirementCount,
+      reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) );
+    VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() );
+    return sparseMemoryRequirements;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void PhysicalDevice::getFeatures2( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 * pFeatures,
+                                                       Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkGetPhysicalDeviceFeatures2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2 *>( pFeatures ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2
+                                         PhysicalDevice::getFeatures2( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 features;
+    d.vkGetPhysicalDeviceFeatures2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2 *>( &features ) );
+    return features;
+  }
+
+  template <typename X, typename Y, typename... Z, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
+                                         PhysicalDevice::getFeatures2( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    StructureChain<X, Y, Z...>                      structureChain;
+    VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 & features =
+      structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2>();
+    d.vkGetPhysicalDeviceFeatures2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2 *>( &features ) );
+    return structureChain;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void PhysicalDevice::getProperties2( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 * pProperties,
+                                                         Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkGetPhysicalDeviceProperties2( m_physicalDevice,
+                                      reinterpret_cast<VkPhysicalDeviceProperties2 *>( pProperties ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2
+                                         PhysicalDevice::getProperties2( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 properties;
+    d.vkGetPhysicalDeviceProperties2( m_physicalDevice,
+                                      reinterpret_cast<VkPhysicalDeviceProperties2 *>( &properties ) );
+    return properties;
+  }
+
+  template <typename X, typename Y, typename... Z, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
+                                         PhysicalDevice::getProperties2( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    StructureChain<X, Y, Z...>                        structureChain;
+    VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 & properties =
+      structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2>();
+    d.vkGetPhysicalDeviceProperties2( m_physicalDevice,
+                                      reinterpret_cast<VkPhysicalDeviceProperties2 *>( &properties ) );
+    return structureChain;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    PhysicalDevice::getFormatProperties2( VULKAN_HPP_NAMESPACE::Format              format,
+                                          VULKAN_HPP_NAMESPACE::FormatProperties2 * pFormatProperties,
+                                          Dispatch const &                          d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkGetPhysicalDeviceFormatProperties2(
+      m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2 *>( pFormatProperties ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::FormatProperties2
+                                         PhysicalDevice::getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format,
+                                          Dispatch const &             d ) const VULKAN_HPP_NOEXCEPT
+  {
+    VULKAN_HPP_NAMESPACE::FormatProperties2 formatProperties;
+    d.vkGetPhysicalDeviceFormatProperties2(
+      m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2 *>( &formatProperties ) );
+    return formatProperties;
+  }
+
+  template <typename X, typename Y, typename... Z, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
+                                         PhysicalDevice::getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format,
+                                          Dispatch const &             d ) const VULKAN_HPP_NOEXCEPT
+  {
+    StructureChain<X, Y, Z...>                structureChain;
+    VULKAN_HPP_NAMESPACE::FormatProperties2 & formatProperties =
+      structureChain.template get<VULKAN_HPP_NAMESPACE::FormatProperties2>();
+    d.vkGetPhysicalDeviceFormatProperties2(
+      m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2 *>( &formatProperties ) );
+    return structureChain;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getImageFormatProperties2(
+    const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 * pImageFormatInfo,
+    VULKAN_HPP_NAMESPACE::ImageFormatProperties2 *               pImageFormatProperties,
+    Dispatch const &                                             d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2(
+      m_physicalDevice,
+      reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( pImageFormatInfo ),
+      reinterpret_cast<VkImageFormatProperties2 *>( pImageFormatProperties ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>::type
+    PhysicalDevice::getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo,
+                                               Dispatch const &                       d ) const
+  {
+    VULKAN_HPP_NAMESPACE::ImageFormatProperties2 imageFormatProperties;
+    Result result = static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2(
+      m_physicalDevice,
+      reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( &imageFormatInfo ),
+      reinterpret_cast<VkImageFormatProperties2 *>( &imageFormatProperties ) ) );
+    return createResultValue(
+      result, imageFormatProperties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2" );
+  }
+
+  template <typename X, typename Y, typename... Z, typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<StructureChain<X, Y, Z...>>::type
+    PhysicalDevice::getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo,
+                                               Dispatch const &                       d ) const
+  {
+    StructureChain<X, Y, Z...>                     structureChain;
+    VULKAN_HPP_NAMESPACE::ImageFormatProperties2 & imageFormatProperties =
+      structureChain.template get<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>();
+    Result result = static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2(
+      m_physicalDevice,
+      reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( &imageFormatInfo ),
+      reinterpret_cast<VkImageFormatProperties2 *>( &imageFormatProperties ) ) );
+    return createResultValue(
+      result, structureChain, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    PhysicalDevice::getQueueFamilyProperties2( uint32_t *                                     pQueueFamilyPropertyCount,
+                                               VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 * pQueueFamilyProperties,
+                                               Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkGetPhysicalDeviceQueueFamilyProperties2(
+      m_physicalDevice,
+      pQueueFamilyPropertyCount,
+      reinterpret_cast<VkQueueFamilyProperties2 *>( pQueueFamilyProperties ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename QueueFamilyProperties2Allocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator>
+                                         PhysicalDevice::getQueueFamilyProperties2( Dispatch const & d ) const
+  {
+    std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator> queueFamilyProperties;
+    uint32_t                                                             queueFamilyPropertyCount;
+    d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
+    queueFamilyProperties.resize( queueFamilyPropertyCount );
+    d.vkGetPhysicalDeviceQueueFamilyProperties2(
+      m_physicalDevice,
+      &queueFamilyPropertyCount,
+      reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) );
+    VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() );
+    return queueFamilyProperties;
+  }
+
+  template <typename QueueFamilyProperties2Allocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, QueueFamilyProperties2>::value, int>::type>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator>
+    PhysicalDevice::getQueueFamilyProperties2( QueueFamilyProperties2Allocator & queueFamilyProperties2Allocator,
+                                               Dispatch const &                  d ) const
+  {
+    std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator> queueFamilyProperties(
+      queueFamilyProperties2Allocator );
+    uint32_t queueFamilyPropertyCount;
+    d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
+    queueFamilyProperties.resize( queueFamilyPropertyCount );
+    d.vkGetPhysicalDeviceQueueFamilyProperties2(
+      m_physicalDevice,
+      &queueFamilyPropertyCount,
+      reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) );
+    VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() );
+    return queueFamilyProperties;
+  }
+
+  template <typename StructureChain, typename StructureChainAllocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<StructureChain, StructureChainAllocator>
+                                         PhysicalDevice::getQueueFamilyProperties2( Dispatch const & d ) const
+  {
+    uint32_t queueFamilyPropertyCount;
+    d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
+    std::vector<StructureChain, StructureChainAllocator>      returnVector( queueFamilyPropertyCount );
+    std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> queueFamilyProperties( queueFamilyPropertyCount );
+    for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ )
+    {
+      queueFamilyProperties[i].pNext =
+        returnVector[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>().pNext;
+    }
+    d.vkGetPhysicalDeviceQueueFamilyProperties2(
+      m_physicalDevice,
+      &queueFamilyPropertyCount,
+      reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) );
+    VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() );
+    for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ )
+    {
+      returnVector[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>() = queueFamilyProperties[i];
+    }
+    return returnVector;
+  }
+
+  template <typename StructureChain,
+            typename StructureChainAllocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, StructureChain>::value, int>::type>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<StructureChain, StructureChainAllocator>
+    PhysicalDevice::getQueueFamilyProperties2( StructureChainAllocator & structureChainAllocator,
+                                               Dispatch const &          d ) const
+  {
+    uint32_t queueFamilyPropertyCount;
+    d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
+    std::vector<StructureChain, StructureChainAllocator>      returnVector( queueFamilyPropertyCount,
+                                                                       structureChainAllocator );
+    std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> queueFamilyProperties( queueFamilyPropertyCount );
+    for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ )
+    {
+      queueFamilyProperties[i].pNext =
+        returnVector[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>().pNext;
+    }
+    d.vkGetPhysicalDeviceQueueFamilyProperties2(
+      m_physicalDevice,
+      &queueFamilyPropertyCount,
+      reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) );
+    VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() );
+    for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ )
+    {
+      returnVector[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>() = queueFamilyProperties[i];
+    }
+    return returnVector;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    PhysicalDevice::getMemoryProperties2( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 * pMemoryProperties,
+                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkGetPhysicalDeviceMemoryProperties2(
+      m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( pMemoryProperties ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2
+    PhysicalDevice::getMemoryProperties2( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 memoryProperties;
+    d.vkGetPhysicalDeviceMemoryProperties2(
+      m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( &memoryProperties ) );
+    return memoryProperties;
+  }
+
+  template <typename X, typename Y, typename... Z, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
+    PhysicalDevice::getMemoryProperties2( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    StructureChain<X, Y, Z...>                              structureChain;
+    VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 & memoryProperties =
+      structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2>();
+    d.vkGetPhysicalDeviceMemoryProperties2(
+      m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( &memoryProperties ) );
+    return structureChain;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void PhysicalDevice::getSparseImageFormatProperties2(
+    const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,
+    uint32_t *                                                         pPropertyCount,
+    VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 *               pProperties,
+    Dispatch const &                                                   d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkGetPhysicalDeviceSparseImageFormatProperties2(
+      m_physicalDevice,
+      reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( pFormatInfo ),
+      pPropertyCount,
+      reinterpret_cast<VkSparseImageFormatProperties2 *>( pProperties ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename SparseImageFormatProperties2Allocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD
+    VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
+    PhysicalDevice::getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
+                                                     Dispatch const &                             d ) const
+  {
+    std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> properties;
+    uint32_t                                                                         propertyCount;
+    d.vkGetPhysicalDeviceSparseImageFormatProperties2(
+      m_physicalDevice,
+      reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ),
+      &propertyCount,
+      nullptr );
+    properties.resize( propertyCount );
+    d.vkGetPhysicalDeviceSparseImageFormatProperties2(
+      m_physicalDevice,
+      reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ),
+      &propertyCount,
+      reinterpret_cast<VkSparseImageFormatProperties2 *>( properties.data() ) );
+    VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+    return properties;
+  }
+
+  template <
+    typename SparseImageFormatProperties2Allocator,
+    typename Dispatch,
+    typename B,
+    typename std::enable_if<std::is_same<typename B::value_type, SparseImageFormatProperties2>::value, int>::type>
+  VULKAN_HPP_NODISCARD
+    VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
+                      PhysicalDevice::getSparseImageFormatProperties2(
+      const PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
+      SparseImageFormatProperties2Allocator &      sparseImageFormatProperties2Allocator,
+      Dispatch const &                             d ) const
+  {
+    std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> properties(
+      sparseImageFormatProperties2Allocator );
+    uint32_t propertyCount;
+    d.vkGetPhysicalDeviceSparseImageFormatProperties2(
+      m_physicalDevice,
+      reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ),
+      &propertyCount,
+      nullptr );
+    properties.resize( propertyCount );
+    d.vkGetPhysicalDeviceSparseImageFormatProperties2(
+      m_physicalDevice,
+      reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ),
+      &propertyCount,
+      reinterpret_cast<VkSparseImageFormatProperties2 *>( properties.data() ) );
+    VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+    return properties;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::trimCommandPool( VULKAN_HPP_NAMESPACE::CommandPool          commandPool,
+                                                  VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags,
+                                                  Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkTrimCommandPool(
+      m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolTrimFlags>( flags ) );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::getQueue2( const VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 * pQueueInfo,
+                                            VULKAN_HPP_NAMESPACE::Queue *                  pQueue,
+                                            Dispatch const &                               d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkGetDeviceQueue2(
+      m_device, reinterpret_cast<const VkDeviceQueueInfo2 *>( pQueueInfo ), reinterpret_cast<VkQueue *>( pQueue ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Queue
+    Device::getQueue2( const DeviceQueueInfo2 & queueInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    VULKAN_HPP_NAMESPACE::Queue queue;
+    d.vkGetDeviceQueue2(
+      m_device, reinterpret_cast<const VkDeviceQueueInfo2 *>( &queueInfo ), reinterpret_cast<VkQueue *>( &queue ) );
+    return queue;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::createSamplerYcbcrConversion( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo * pCreateInfo,
+                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks *              pAllocator,
+                                          VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion * pYcbcrConversion,
+                                          Dispatch const &                               d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkCreateSamplerYcbcrConversion( m_device,
+                                        reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo *>( pCreateInfo ),
+                                        reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
+                                        reinterpret_cast<VkSamplerYcbcrConversion *>( pYcbcrConversion ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>::type
+    Device::createSamplerYcbcrConversion( const SamplerYcbcrConversionCreateInfo & createInfo,
+                                          Optional<const AllocationCallbacks>      allocator,
+                                          Dispatch const &                         d ) const
+  {
+    VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion;
+    Result                                       result = static_cast<Result>(
+      d.vkCreateSamplerYcbcrConversion( m_device,
+                                        reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo *>( &createInfo ),
+                                        reinterpret_cast<const VkAllocationCallbacks *>(
+                                          static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                        reinterpret_cast<VkSamplerYcbcrConversion *>( &ycbcrConversion ) ) );
+    return createResultValue(
+      result, ycbcrConversion, VULKAN_HPP_NAMESPACE_STRING "::Device::createSamplerYcbcrConversion" );
+  }
+
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, Dispatch>>::type
+    Device::createSamplerYcbcrConversionUnique( const SamplerYcbcrConversionCreateInfo & createInfo,
+                                                Optional<const AllocationCallbacks>      allocator,
+                                                Dispatch const &                         d ) const
+  {
+    VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion;
+    Result                                       result = static_cast<Result>(
+      d.vkCreateSamplerYcbcrConversion( m_device,
+                                        reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo *>( &createInfo ),
+                                        reinterpret_cast<const VkAllocationCallbacks *>(
+                                          static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                        reinterpret_cast<VkSamplerYcbcrConversion *>( &ycbcrConversion ) ) );
+    ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
+    return createResultValue<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, Dispatch>(
+      result, ycbcrConversion, VULKAN_HPP_NAMESPACE_STRING "::Device::createSamplerYcbcrConversionUnique", deleter );
+  }
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    Device::destroySamplerYcbcrConversion( 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::destroySamplerYcbcrConversion( 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 VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#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 VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createDescriptorUpdateTemplate(
     const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo * pCreateInfo,
@@ -106463,6 +107947,4529 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    Device::destroyDescriptorUpdateTemplate( 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::destroyDescriptorUpdateTemplate( 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 VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#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 VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    Device::updateDescriptorSetWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorSet            descriptorSet,
+                                             VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
+                                             const void *                                   pData,
+                                             Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkUpdateDescriptorSetWithTemplate( m_device,
+                                         static_cast<VkDescriptorSet>( descriptorSet ),
+                                         static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
+                                         pData );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void PhysicalDevice::getExternalBufferProperties(
+    const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo * pExternalBufferInfo,
+    VULKAN_HPP_NAMESPACE::ExternalBufferProperties *               pExternalBufferProperties,
+    Dispatch const &                                               d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkGetPhysicalDeviceExternalBufferProperties(
+      m_physicalDevice,
+      reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo *>( pExternalBufferInfo ),
+      reinterpret_cast<VkExternalBufferProperties *>( pExternalBufferProperties ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalBufferProperties
+    PhysicalDevice::getExternalBufferProperties( const PhysicalDeviceExternalBufferInfo & externalBufferInfo,
+                                                 Dispatch const &                         d ) const VULKAN_HPP_NOEXCEPT
+  {
+    VULKAN_HPP_NAMESPACE::ExternalBufferProperties externalBufferProperties;
+    d.vkGetPhysicalDeviceExternalBufferProperties(
+      m_physicalDevice,
+      reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo *>( &externalBufferInfo ),
+      reinterpret_cast<VkExternalBufferProperties *>( &externalBufferProperties ) );
+    return externalBufferProperties;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void PhysicalDevice::getExternalFenceProperties(
+    const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo * pExternalFenceInfo,
+    VULKAN_HPP_NAMESPACE::ExternalFenceProperties *               pExternalFenceProperties,
+    Dispatch const &                                              d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkGetPhysicalDeviceExternalFenceProperties(
+      m_physicalDevice,
+      reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo *>( pExternalFenceInfo ),
+      reinterpret_cast<VkExternalFenceProperties *>( pExternalFenceProperties ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalFenceProperties
+    PhysicalDevice::getExternalFenceProperties( const PhysicalDeviceExternalFenceInfo & externalFenceInfo,
+                                                Dispatch const &                        d ) const VULKAN_HPP_NOEXCEPT
+  {
+    VULKAN_HPP_NAMESPACE::ExternalFenceProperties externalFenceProperties;
+    d.vkGetPhysicalDeviceExternalFenceProperties(
+      m_physicalDevice,
+      reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo *>( &externalFenceInfo ),
+      reinterpret_cast<VkExternalFenceProperties *>( &externalFenceProperties ) );
+    return externalFenceProperties;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void PhysicalDevice::getExternalSemaphoreProperties(
+    const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,
+    VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties *               pExternalSemaphoreProperties,
+    Dispatch const &                                                  d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkGetPhysicalDeviceExternalSemaphoreProperties(
+      m_physicalDevice,
+      reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo *>( pExternalSemaphoreInfo ),
+      reinterpret_cast<VkExternalSemaphoreProperties *>( pExternalSemaphoreProperties ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties
+    PhysicalDevice::getExternalSemaphoreProperties( const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo,
+                                                    Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties externalSemaphoreProperties;
+    d.vkGetPhysicalDeviceExternalSemaphoreProperties(
+      m_physicalDevice,
+      reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo *>( &externalSemaphoreInfo ),
+      reinterpret_cast<VkExternalSemaphoreProperties *>( &externalSemaphoreProperties ) );
+    return externalSemaphoreProperties;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    Device::getDescriptorSetLayoutSupport( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo * pCreateInfo,
+                                           VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport *          pSupport,
+                                           Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkGetDescriptorSetLayoutSupport( m_device,
+                                       reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( pCreateInfo ),
+                                       reinterpret_cast<VkDescriptorSetLayoutSupport *>( pSupport ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport
+    Device::getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo,
+                                           Dispatch const &                      d ) const VULKAN_HPP_NOEXCEPT
+  {
+    VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport support;
+    d.vkGetDescriptorSetLayoutSupport( m_device,
+                                       reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ),
+                                       reinterpret_cast<VkDescriptorSetLayoutSupport *>( &support ) );
+    return support;
+  }
+
+  template <typename X, typename Y, typename... Z, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
+    Device::getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo,
+                                           Dispatch const &                      d ) const VULKAN_HPP_NOEXCEPT
+  {
+    StructureChain<X, Y, Z...>                         structureChain;
+    VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport & support =
+      structureChain.template get<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport>();
+    d.vkGetDescriptorSetLayoutSupport( m_device,
+                                       reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ),
+                                       reinterpret_cast<VkDescriptorSetLayoutSupport *>( &support ) );
+    return structureChain;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  //=== VK_VERSION_1_2 ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCount( VULKAN_HPP_NAMESPACE::Buffer     buffer,
+                                                           VULKAN_HPP_NAMESPACE::DeviceSize offset,
+                                                           VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
+                                                           VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
+                                                           uint32_t                         maxDrawCount,
+                                                           uint32_t                         stride,
+                                                           Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdDrawIndirectCount( m_commandBuffer,
+                              static_cast<VkBuffer>( buffer ),
+                              static_cast<VkDeviceSize>( offset ),
+                              static_cast<VkBuffer>( countBuffer ),
+                              static_cast<VkDeviceSize>( countBufferOffset ),
+                              maxDrawCount,
+                              stride );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCount( VULKAN_HPP_NAMESPACE::Buffer     buffer,
+                                                                  VULKAN_HPP_NAMESPACE::DeviceSize offset,
+                                                                  VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
+                                                                  VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
+                                                                  uint32_t                         maxDrawCount,
+                                                                  uint32_t                         stride,
+                                                                  Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdDrawIndexedIndirectCount( m_commandBuffer,
+                                     static_cast<VkBuffer>( buffer ),
+                                     static_cast<VkDeviceSize>( offset ),
+                                     static_cast<VkBuffer>( countBuffer ),
+                                     static_cast<VkDeviceSize>( countBufferOffset ),
+                                     maxDrawCount,
+                                     stride );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::createRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 * pCreateInfo,
+                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
+                               VULKAN_HPP_NAMESPACE::RenderPass *                  pRenderPass,
+                               Dispatch const &                                    d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkCreateRenderPass2( m_device,
+                                                       reinterpret_cast<const VkRenderPassCreateInfo2 *>( pCreateInfo ),
+                                                       reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
+                                                       reinterpret_cast<VkRenderPass *>( pRenderPass ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::RenderPass>::type
+    Device::createRenderPass2( const RenderPassCreateInfo2 &       createInfo,
+                               Optional<const AllocationCallbacks> allocator,
+                               Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::RenderPass renderPass;
+    Result                           result = static_cast<Result>(
+      d.vkCreateRenderPass2( m_device,
+                             reinterpret_cast<const VkRenderPassCreateInfo2 *>( &createInfo ),
+                             reinterpret_cast<const VkAllocationCallbacks *>(
+                               static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                             reinterpret_cast<VkRenderPass *>( &renderPass ) ) );
+    return createResultValue( result, renderPass, VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPass2" );
+  }
+
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type
+    Device::createRenderPass2Unique( const RenderPassCreateInfo2 &       createInfo,
+                                     Optional<const AllocationCallbacks> allocator,
+                                     Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::RenderPass renderPass;
+    Result                           result = static_cast<Result>(
+      d.vkCreateRenderPass2( m_device,
+                             reinterpret_cast<const VkRenderPassCreateInfo2 *>( &createInfo ),
+                             reinterpret_cast<const VkAllocationCallbacks *>(
+                               static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                             reinterpret_cast<VkRenderPass *>( &renderPass ) ) );
+    ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
+    return createResultValue<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>(
+      result, renderPass, VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPass2Unique", deleter );
+  }
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    CommandBuffer::beginRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo * pRenderPassBegin,
+                                     const VULKAN_HPP_NAMESPACE::SubpassBeginInfo *    pSubpassBeginInfo,
+                                     Dispatch const &                                  d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdBeginRenderPass2( m_commandBuffer,
+                             reinterpret_cast<const VkRenderPassBeginInfo *>( pRenderPassBegin ),
+                             reinterpret_cast<const VkSubpassBeginInfo *>( pSubpassBeginInfo ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass2( const RenderPassBeginInfo & renderPassBegin,
+                                                          const SubpassBeginInfo &    subpassBeginInfo,
+                                                          Dispatch const &            d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdBeginRenderPass2( m_commandBuffer,
+                             reinterpret_cast<const VkRenderPassBeginInfo *>( &renderPassBegin ),
+                             reinterpret_cast<const VkSubpassBeginInfo *>( &subpassBeginInfo ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo * pSubpassBeginInfo,
+                                                      const VULKAN_HPP_NAMESPACE::SubpassEndInfo *   pSubpassEndInfo,
+                                                      Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdNextSubpass2( m_commandBuffer,
+                         reinterpret_cast<const VkSubpassBeginInfo *>( pSubpassBeginInfo ),
+                         reinterpret_cast<const VkSubpassEndInfo *>( pSubpassEndInfo ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2( const SubpassBeginInfo & subpassBeginInfo,
+                                                      const SubpassEndInfo &   subpassEndInfo,
+                                                      Dispatch const &         d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdNextSubpass2( m_commandBuffer,
+                         reinterpret_cast<const VkSubpassBeginInfo *>( &subpassBeginInfo ),
+                         reinterpret_cast<const VkSubpassEndInfo *>( &subpassEndInfo ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2( const VULKAN_HPP_NAMESPACE::SubpassEndInfo * pSubpassEndInfo,
+                                                        Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdEndRenderPass2( m_commandBuffer, reinterpret_cast<const VkSubpassEndInfo *>( pSubpassEndInfo ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2( const SubpassEndInfo & subpassEndInfo,
+                                                        Dispatch const &       d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdEndRenderPass2( m_commandBuffer, reinterpret_cast<const VkSubpassEndInfo *>( &subpassEndInfo ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::resetQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
+                                                 uint32_t                        firstQuery,
+                                                 uint32_t                        queryCount,
+                                                 Dispatch const &                d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkResetQueryPool( m_device, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSemaphoreCounterValue(
+    VULKAN_HPP_NAMESPACE::Semaphore semaphore, uint64_t * pValue, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkGetSemaphoreCounterValue( m_device, static_cast<VkSemaphore>( semaphore ), pValue ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<uint64_t>::type
+    Device::getSemaphoreCounterValue( VULKAN_HPP_NAMESPACE::Semaphore semaphore, Dispatch const & d ) const
+  {
+    uint64_t value;
+    Result   result =
+      static_cast<Result>( d.vkGetSemaphoreCounterValue( m_device, static_cast<VkSemaphore>( semaphore ), &value ) );
+    return createResultValue( result, value, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreCounterValue" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::waitSemaphores( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo * pWaitInfo,
+                            uint64_t                                        timeout,
+                            Dispatch const &                                d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkWaitSemaphores( m_device, reinterpret_cast<const VkSemaphoreWaitInfo *>( pWaitInfo ), timeout ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::waitSemaphores( const SemaphoreWaitInfo & waitInfo,
+                                                                        uint64_t                  timeout,
+                                                                        Dispatch const &          d ) const
+  {
+    Result result = static_cast<Result>(
+      d.vkWaitSemaphores( m_device, reinterpret_cast<const VkSemaphoreWaitInfo *>( &waitInfo ), timeout ) );
+    return createResultValue( result,
+                              VULKAN_HPP_NAMESPACE_STRING "::Device::waitSemaphores",
+                              { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eTimeout } );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::signalSemaphore(
+    const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo * pSignalInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkSignalSemaphore( m_device, reinterpret_cast<const VkSemaphoreSignalInfo *>( pSignalInfo ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
+    Device::signalSemaphore( const SemaphoreSignalInfo & signalInfo, Dispatch const & d ) const
+  {
+    Result result = static_cast<Result>(
+      d.vkSignalSemaphore( m_device, reinterpret_cast<const VkSemaphoreSignalInfo *>( &signalInfo ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::signalSemaphore" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,
+                                                            Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<DeviceAddress>(
+      d.vkGetBufferDeviceAddress( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo *>( pInfo ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddress( const BufferDeviceAddressInfo & info,
+                                                            Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return d.vkGetBufferDeviceAddress( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE uint64_t Device::getBufferOpaqueCaptureAddress(
+    const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return d.vkGetBufferOpaqueCaptureAddress( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo *>( pInfo ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE uint64_t Device::getBufferOpaqueCaptureAddress( const BufferDeviceAddressInfo & info,
+                                                                    Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return d.vkGetBufferOpaqueCaptureAddress( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE uint64_t
+    Device::getMemoryOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo * pInfo,
+                                           Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return d.vkGetDeviceMemoryOpaqueCaptureAddress(
+      m_device, reinterpret_cast<const VkDeviceMemoryOpaqueCaptureAddressInfo *>( pInfo ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE uint64_t Device::getMemoryOpaqueCaptureAddress( const DeviceMemoryOpaqueCaptureAddressInfo & info,
+                                                                    Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return d.vkGetDeviceMemoryOpaqueCaptureAddress(
+      m_device, reinterpret_cast<const VkDeviceMemoryOpaqueCaptureAddressInfo *>( &info ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  //=== VK_KHR_surface ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Instance::destroySurfaceKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR                  surface,
+                                                      const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                                      Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroySurfaceKHR(
+      m_instance, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Instance::destroySurfaceKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR    surface,
+                                                      Optional<const AllocationCallbacks> allocator,
+                                                      Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroySurfaceKHR( m_instance,
+                           static_cast<VkSurfaceKHR>( surface ),
+                           reinterpret_cast<const VkAllocationCallbacks *>(
+                             static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Instance::destroy( VULKAN_HPP_NAMESPACE::SurfaceKHR                  surface,
+                                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                            Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroySurfaceKHR(
+      m_instance, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Instance::destroy( VULKAN_HPP_NAMESPACE::SurfaceKHR    surface,
+                                            Optional<const AllocationCallbacks> allocator,
+                                            Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroySurfaceKHR( m_instance,
+                           static_cast<VkSurfaceKHR>( surface ),
+                           reinterpret_cast<const VkAllocationCallbacks *>(
+                             static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    PhysicalDevice::getSurfaceSupportKHR( uint32_t                         queueFamilyIndex,
+                                          VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
+                                          VULKAN_HPP_NAMESPACE::Bool32 *   pSupported,
+                                          Dispatch const &                 d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkGetPhysicalDeviceSurfaceSupportKHR( m_physicalDevice,
+                                                                        queueFamilyIndex,
+                                                                        static_cast<VkSurfaceKHR>( surface ),
+                                                                        reinterpret_cast<VkBool32 *>( pSupported ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::Bool32>::type
+                                          PhysicalDevice::getSurfaceSupportKHR( uint32_t                         queueFamilyIndex,
+                                          VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
+                                          Dispatch const &                 d ) const
+  {
+    VULKAN_HPP_NAMESPACE::Bool32 supported;
+    Result                       result =
+      static_cast<Result>( d.vkGetPhysicalDeviceSurfaceSupportKHR( m_physicalDevice,
+                                                                   queueFamilyIndex,
+                                                                   static_cast<VkSurfaceKHR>( surface ),
+                                                                   reinterpret_cast<VkBool32 *>( &supported ) ) );
+    return createResultValue( result, supported, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceSupportKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    PhysicalDevice::getSurfaceCapabilitiesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR               surface,
+                                               VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR * pSurfaceCapabilities,
+                                               Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
+      m_physicalDevice,
+      static_cast<VkSurfaceKHR>( surface ),
+      reinterpret_cast<VkSurfaceCapabilitiesKHR *>( pSurfaceCapabilities ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR>::type
+    PhysicalDevice::getSurfaceCapabilitiesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d ) const
+  {
+    VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR surfaceCapabilities;
+    Result result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
+      m_physicalDevice,
+      static_cast<VkSurfaceKHR>( surface ),
+      reinterpret_cast<VkSurfaceCapabilitiesKHR *>( &surfaceCapabilities ) ) );
+    return createResultValue(
+      result, surfaceCapabilities, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilitiesKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    PhysicalDevice::getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR         surface,
+                                          uint32_t *                               pSurfaceFormatCount,
+                                          VULKAN_HPP_NAMESPACE::SurfaceFormatKHR * pSurfaceFormats,
+                                          Dispatch const &                         d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice,
+                                              static_cast<VkSurfaceKHR>( surface ),
+                                              pSurfaceFormatCount,
+                                              reinterpret_cast<VkSurfaceFormatKHR *>( pSurfaceFormats ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename SurfaceFormatKHRAllocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
+    typename ResultValueType<std::vector<SurfaceFormatKHR, SurfaceFormatKHRAllocator>>::type
+    PhysicalDevice::getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d ) const
+  {
+    std::vector<SurfaceFormatKHR, SurfaceFormatKHRAllocator> surfaceFormats;
+    uint32_t                                                 surfaceFormatCount;
+    Result                                                   result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormatsKHR(
+        m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &surfaceFormatCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && surfaceFormatCount )
+      {
+        surfaceFormats.resize( surfaceFormatCount );
+        result = static_cast<Result>(
+          d.vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice,
+                                                  static_cast<VkSurfaceKHR>( surface ),
+                                                  &surfaceFormatCount,
+                                                  reinterpret_cast<VkSurfaceFormatKHR *>( surfaceFormats.data() ) ) );
+        VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( surfaceFormatCount < surfaceFormats.size() ) )
+    {
+      surfaceFormats.resize( surfaceFormatCount );
+    }
+    return createResultValue(
+      result, surfaceFormats, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceFormatsKHR" );
+  }
+
+  template <typename SurfaceFormatKHRAllocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, SurfaceFormatKHR>::value, int>::type>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
+    typename ResultValueType<std::vector<SurfaceFormatKHR, SurfaceFormatKHRAllocator>>::type
+    PhysicalDevice::getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
+                                          SurfaceFormatKHRAllocator &      surfaceFormatKHRAllocator,
+                                          Dispatch const &                 d ) const
+  {
+    std::vector<SurfaceFormatKHR, SurfaceFormatKHRAllocator> surfaceFormats( surfaceFormatKHRAllocator );
+    uint32_t                                                 surfaceFormatCount;
+    Result                                                   result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormatsKHR(
+        m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &surfaceFormatCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && surfaceFormatCount )
+      {
+        surfaceFormats.resize( surfaceFormatCount );
+        result = static_cast<Result>(
+          d.vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice,
+                                                  static_cast<VkSurfaceKHR>( surface ),
+                                                  &surfaceFormatCount,
+                                                  reinterpret_cast<VkSurfaceFormatKHR *>( surfaceFormats.data() ) ) );
+        VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( surfaceFormatCount < surfaceFormats.size() ) )
+    {
+      surfaceFormats.resize( surfaceFormatCount );
+    }
+    return createResultValue(
+      result, surfaceFormats, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceFormatsKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    PhysicalDevice::getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR       surface,
+                                               uint32_t *                             pPresentModeCount,
+                                               VULKAN_HPP_NAMESPACE::PresentModeKHR * pPresentModes,
+                                               Dispatch const &                       d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice,
+                                                   static_cast<VkSurfaceKHR>( surface ),
+                                                   pPresentModeCount,
+                                                   reinterpret_cast<VkPresentModeKHR *>( pPresentModes ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename PresentModeKHRAllocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
+    typename ResultValueType<std::vector<PresentModeKHR, PresentModeKHRAllocator>>::type
+    PhysicalDevice::getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d ) const
+  {
+    std::vector<PresentModeKHR, PresentModeKHRAllocator> presentModes;
+    uint32_t                                             presentModeCount;
+    Result                                               result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetPhysicalDeviceSurfacePresentModesKHR(
+        m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &presentModeCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && presentModeCount )
+      {
+        presentModes.resize( presentModeCount );
+        result = static_cast<Result>(
+          d.vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice,
+                                                       static_cast<VkSurfaceKHR>( surface ),
+                                                       &presentModeCount,
+                                                       reinterpret_cast<VkPresentModeKHR *>( presentModes.data() ) ) );
+        VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( presentModeCount < presentModes.size() ) )
+    {
+      presentModes.resize( presentModeCount );
+    }
+    return createResultValue(
+      result, presentModes, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfacePresentModesKHR" );
+  }
+
+  template <typename PresentModeKHRAllocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, PresentModeKHR>::value, int>::type>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
+    typename ResultValueType<std::vector<PresentModeKHR, PresentModeKHRAllocator>>::type
+    PhysicalDevice::getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
+                                               PresentModeKHRAllocator &        presentModeKHRAllocator,
+                                               Dispatch const &                 d ) const
+  {
+    std::vector<PresentModeKHR, PresentModeKHRAllocator> presentModes( presentModeKHRAllocator );
+    uint32_t                                             presentModeCount;
+    Result                                               result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetPhysicalDeviceSurfacePresentModesKHR(
+        m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &presentModeCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && presentModeCount )
+      {
+        presentModes.resize( presentModeCount );
+        result = static_cast<Result>(
+          d.vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice,
+                                                       static_cast<VkSurfaceKHR>( surface ),
+                                                       &presentModeCount,
+                                                       reinterpret_cast<VkPresentModeKHR *>( presentModes.data() ) ) );
+        VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( presentModeCount < presentModes.size() ) )
+    {
+      presentModes.resize( presentModeCount );
+    }
+    return createResultValue(
+      result, presentModes, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfacePresentModesKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  //=== VK_KHR_swapchain ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::createSwapchainKHR( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR * pCreateInfo,
+                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks *    pAllocator,
+                                VULKAN_HPP_NAMESPACE::SwapchainKHR *                 pSwapchain,
+                                Dispatch const &                                     d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkCreateSwapchainKHR( m_device,
+                              reinterpret_cast<const VkSwapchainCreateInfoKHR *>( pCreateInfo ),
+                              reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
+                              reinterpret_cast<VkSwapchainKHR *>( pSwapchain ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::SwapchainKHR>::type
+    Device::createSwapchainKHR( const SwapchainCreateInfoKHR &      createInfo,
+                                Optional<const AllocationCallbacks> allocator,
+                                Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain;
+    Result                             result = static_cast<Result>(
+      d.vkCreateSwapchainKHR( m_device,
+                              reinterpret_cast<const VkSwapchainCreateInfoKHR *>( &createInfo ),
+                              reinterpret_cast<const VkAllocationCallbacks *>(
+                                static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                              reinterpret_cast<VkSwapchainKHR *>( &swapchain ) ) );
+    return createResultValue( result, swapchain, VULKAN_HPP_NAMESPACE_STRING "::Device::createSwapchainKHR" );
+  }
+
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>::type
+    Device::createSwapchainKHRUnique( const SwapchainCreateInfoKHR &      createInfo,
+                                      Optional<const AllocationCallbacks> allocator,
+                                      Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain;
+    Result                             result = static_cast<Result>(
+      d.vkCreateSwapchainKHR( m_device,
+                              reinterpret_cast<const VkSwapchainCreateInfoKHR *>( &createInfo ),
+                              reinterpret_cast<const VkAllocationCallbacks *>(
+                                static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                              reinterpret_cast<VkSwapchainKHR *>( &swapchain ) ) );
+    ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
+    return createResultValue<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>(
+      result, swapchain, VULKAN_HPP_NAMESPACE_STRING "::Device::createSwapchainKHRUnique", deleter );
+  }
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroySwapchainKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR                swapchain,
+                                                      const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                                      Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroySwapchainKHR( m_device,
+                             static_cast<VkSwapchainKHR>( swapchain ),
+                             reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroySwapchainKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR  swapchain,
+                                                      Optional<const AllocationCallbacks> allocator,
+                                                      Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroySwapchainKHR( m_device,
+                             static_cast<VkSwapchainKHR>( swapchain ),
+                             reinterpret_cast<const VkAllocationCallbacks *>(
+                               static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::SwapchainKHR                swapchain,
+                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroySwapchainKHR( m_device,
+                             static_cast<VkSwapchainKHR>( swapchain ),
+                             reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::SwapchainKHR  swapchain,
+                                          Optional<const AllocationCallbacks> allocator,
+                                          Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroySwapchainKHR( m_device,
+                             static_cast<VkSwapchainKHR>( swapchain ),
+                             reinterpret_cast<const VkAllocationCallbacks *>(
+                               static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::getSwapchainImagesKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
+                                   uint32_t *                         pSwapchainImageCount,
+                                   VULKAN_HPP_NAMESPACE::Image *      pSwapchainImages,
+                                   Dispatch const &                   d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkGetSwapchainImagesKHR( m_device,
+                                                           static_cast<VkSwapchainKHR>( swapchain ),
+                                                           pSwapchainImageCount,
+                                                           reinterpret_cast<VkImage *>( pSwapchainImages ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename ImageAllocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<Image, ImageAllocator>>::type
+    Device::getSwapchainImagesKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d ) const
+  {
+    std::vector<Image, ImageAllocator> swapchainImages;
+    uint32_t                           swapchainImageCount;
+    Result                             result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetSwapchainImagesKHR(
+        m_device, static_cast<VkSwapchainKHR>( swapchain ), &swapchainImageCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && swapchainImageCount )
+      {
+        swapchainImages.resize( swapchainImageCount );
+        result =
+          static_cast<Result>( d.vkGetSwapchainImagesKHR( m_device,
+                                                          static_cast<VkSwapchainKHR>( swapchain ),
+                                                          &swapchainImageCount,
+                                                          reinterpret_cast<VkImage *>( swapchainImages.data() ) ) );
+        VULKAN_HPP_ASSERT( swapchainImageCount <= swapchainImages.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( swapchainImageCount < swapchainImages.size() ) )
+    {
+      swapchainImages.resize( swapchainImageCount );
+    }
+    return createResultValue( result, swapchainImages, VULKAN_HPP_NAMESPACE_STRING "::Device::getSwapchainImagesKHR" );
+  }
+
+  template <typename ImageAllocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, Image>::value, int>::type>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<Image, ImageAllocator>>::type
+                       Device::getSwapchainImagesKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
+                                   ImageAllocator &                   imageAllocator,
+                                   Dispatch const &                   d ) const
+  {
+    std::vector<Image, ImageAllocator> swapchainImages( imageAllocator );
+    uint32_t                           swapchainImageCount;
+    Result                             result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetSwapchainImagesKHR(
+        m_device, static_cast<VkSwapchainKHR>( swapchain ), &swapchainImageCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && swapchainImageCount )
+      {
+        swapchainImages.resize( swapchainImageCount );
+        result =
+          static_cast<Result>( d.vkGetSwapchainImagesKHR( m_device,
+                                                          static_cast<VkSwapchainKHR>( swapchain ),
+                                                          &swapchainImageCount,
+                                                          reinterpret_cast<VkImage *>( swapchainImages.data() ) ) );
+        VULKAN_HPP_ASSERT( swapchainImageCount <= swapchainImages.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( swapchainImageCount < swapchainImages.size() ) )
+    {
+      swapchainImages.resize( swapchainImageCount );
+    }
+    return createResultValue( result, swapchainImages, VULKAN_HPP_NAMESPACE_STRING "::Device::getSwapchainImagesKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::acquireNextImageKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
+                                 uint64_t                           timeout,
+                                 VULKAN_HPP_NAMESPACE::Semaphore    semaphore,
+                                 VULKAN_HPP_NAMESPACE::Fence        fence,
+                                 uint32_t *                         pImageIndex,
+                                 Dispatch const &                   d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkAcquireNextImageKHR( m_device,
+                                                         static_cast<VkSwapchainKHR>( swapchain ),
+                                                         timeout,
+                                                         static_cast<VkSemaphore>( semaphore ),
+                                                         static_cast<VkFence>( fence ),
+                                                         pImageIndex ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<uint32_t>
+                                         Device::acquireNextImageKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
+                                 uint64_t                           timeout,
+                                 VULKAN_HPP_NAMESPACE::Semaphore    semaphore,
+                                 VULKAN_HPP_NAMESPACE::Fence        fence,
+                                 Dispatch const &                   d ) const
+  {
+    uint32_t imageIndex;
+    Result   result = static_cast<Result>( d.vkAcquireNextImageKHR( m_device,
+                                                                  static_cast<VkSwapchainKHR>( swapchain ),
+                                                                  timeout,
+                                                                  static_cast<VkSemaphore>( semaphore ),
+                                                                  static_cast<VkFence>( fence ),
+                                                                  &imageIndex ) );
+    return createResultValue( result,
+                              imageIndex,
+                              VULKAN_HPP_NAMESPACE_STRING "::Device::acquireNextImageKHR",
+                              { VULKAN_HPP_NAMESPACE::Result::eSuccess,
+                                VULKAN_HPP_NAMESPACE::Result::eTimeout,
+                                VULKAN_HPP_NAMESPACE::Result::eNotReady,
+                                VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR } );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Queue::presentKHR(
+    const VULKAN_HPP_NAMESPACE::PresentInfoKHR * pPresentInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkQueuePresentKHR( m_queue, reinterpret_cast<const VkPresentInfoKHR *>( pPresentInfo ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Queue::presentKHR( const PresentInfoKHR & presentInfo,
+                                                                   Dispatch const &       d ) const
+  {
+    Result result =
+      static_cast<Result>( d.vkQueuePresentKHR( m_queue, reinterpret_cast<const VkPresentInfoKHR *>( &presentInfo ) ) );
+    return createResultValue(
+      result,
+      VULKAN_HPP_NAMESPACE_STRING "::Queue::presentKHR",
+      { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR } );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getGroupPresentCapabilitiesKHR(
+    VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR * pDeviceGroupPresentCapabilities,
+    Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkGetDeviceGroupPresentCapabilitiesKHR(
+      m_device, reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR *>( pDeviceGroupPresentCapabilities ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR>::type
+    Device::getGroupPresentCapabilitiesKHR( Dispatch const & d ) const
+  {
+    VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR deviceGroupPresentCapabilities;
+    Result result = static_cast<Result>( d.vkGetDeviceGroupPresentCapabilitiesKHR(
+      m_device, reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR *>( &deviceGroupPresentCapabilities ) ) );
+    return createResultValue(
+      result, deviceGroupPresentCapabilities, VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupPresentCapabilitiesKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::getGroupSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR                       surface,
+                                            VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR * pModes,
+                                            Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkGetDeviceGroupSurfacePresentModesKHR( m_device,
+                                                static_cast<VkSurfaceKHR>( surface ),
+                                                reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR *>( pModes ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR>::type
+    Device::getGroupSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d ) const
+  {
+    VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR modes;
+    Result                                               result = static_cast<Result>(
+      d.vkGetDeviceGroupSurfacePresentModesKHR( m_device,
+                                                static_cast<VkSurfaceKHR>( surface ),
+                                                reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR *>( &modes ) ) );
+    return createResultValue( result, modes, VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupSurfacePresentModesKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    PhysicalDevice::getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
+                                             uint32_t *                       pRectCount,
+                                             VULKAN_HPP_NAMESPACE::Rect2D *   pRects,
+                                             Dispatch const &                 d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkGetPhysicalDevicePresentRectanglesKHR(
+      m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), pRectCount, reinterpret_cast<VkRect2D *>( pRects ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Rect2DAllocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<Rect2D, Rect2DAllocator>>::type
+    PhysicalDevice::getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d ) const
+  {
+    std::vector<Rect2D, Rect2DAllocator> rects;
+    uint32_t                             rectCount;
+    Result                               result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetPhysicalDevicePresentRectanglesKHR(
+        m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &rectCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && rectCount )
+      {
+        rects.resize( rectCount );
+        result = static_cast<Result>(
+          d.vkGetPhysicalDevicePresentRectanglesKHR( m_physicalDevice,
+                                                     static_cast<VkSurfaceKHR>( surface ),
+                                                     &rectCount,
+                                                     reinterpret_cast<VkRect2D *>( rects.data() ) ) );
+        VULKAN_HPP_ASSERT( rectCount <= rects.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( rectCount < rects.size() ) )
+    {
+      rects.resize( rectCount );
+    }
+    return createResultValue( result, rects, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getPresentRectanglesKHR" );
+  }
+
+  template <typename Rect2DAllocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, Rect2D>::value, int>::type>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<Rect2D, Rect2DAllocator>>::type
+                       PhysicalDevice::getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
+                                             Rect2DAllocator &                rect2DAllocator,
+                                             Dispatch const &                 d ) const
+  {
+    std::vector<Rect2D, Rect2DAllocator> rects( rect2DAllocator );
+    uint32_t                             rectCount;
+    Result                               result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetPhysicalDevicePresentRectanglesKHR(
+        m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &rectCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && rectCount )
+      {
+        rects.resize( rectCount );
+        result = static_cast<Result>(
+          d.vkGetPhysicalDevicePresentRectanglesKHR( m_physicalDevice,
+                                                     static_cast<VkSurfaceKHR>( surface ),
+                                                     &rectCount,
+                                                     reinterpret_cast<VkRect2D *>( rects.data() ) ) );
+        VULKAN_HPP_ASSERT( rectCount <= rects.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( rectCount < rects.size() ) )
+    {
+      rects.resize( rectCount );
+    }
+    return createResultValue( result, rects, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getPresentRectanglesKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::acquireNextImage2KHR( const VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR * pAcquireInfo,
+                                  uint32_t *                                            pImageIndex,
+                                  Dispatch const &                                      d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkAcquireNextImage2KHR(
+      m_device, reinterpret_cast<const VkAcquireNextImageInfoKHR *>( pAcquireInfo ), pImageIndex ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<uint32_t>
+    Device::acquireNextImage2KHR( const AcquireNextImageInfoKHR & acquireInfo, Dispatch const & d ) const
+  {
+    uint32_t imageIndex;
+    Result   result = static_cast<Result>( d.vkAcquireNextImage2KHR(
+      m_device, reinterpret_cast<const VkAcquireNextImageInfoKHR *>( &acquireInfo ), &imageIndex ) );
+    return createResultValue( result,
+                              imageIndex,
+                              VULKAN_HPP_NAMESPACE_STRING "::Device::acquireNextImage2KHR",
+                              { VULKAN_HPP_NAMESPACE::Result::eSuccess,
+                                VULKAN_HPP_NAMESPACE::Result::eTimeout,
+                                VULKAN_HPP_NAMESPACE::Result::eNotReady,
+                                VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR } );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  //=== VK_KHR_display ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    PhysicalDevice::getDisplayPropertiesKHR( uint32_t *                                   pPropertyCount,
+                                             VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR * pProperties,
+                                             Dispatch const &                             d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkGetPhysicalDeviceDisplayPropertiesKHR(
+      m_physicalDevice, pPropertyCount, reinterpret_cast<VkDisplayPropertiesKHR *>( pProperties ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename DisplayPropertiesKHRAllocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
+    typename ResultValueType<std::vector<DisplayPropertiesKHR, DisplayPropertiesKHRAllocator>>::type
+    PhysicalDevice::getDisplayPropertiesKHR( Dispatch const & d ) const
+  {
+    std::vector<DisplayPropertiesKHR, DisplayPropertiesKHRAllocator> properties;
+    uint32_t                                                         propertyCount;
+    Result                                                           result;
+    do
+    {
+      result =
+        static_cast<Result>( d.vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && propertyCount )
+      {
+        properties.resize( propertyCount );
+        result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPropertiesKHR(
+          m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPropertiesKHR *>( properties.data() ) ) );
+        VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) )
+    {
+      properties.resize( propertyCount );
+    }
+    return createResultValue(
+      result, properties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPropertiesKHR" );
+  }
+
+  template <typename DisplayPropertiesKHRAllocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, DisplayPropertiesKHR>::value, int>::type>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
+    typename ResultValueType<std::vector<DisplayPropertiesKHR, DisplayPropertiesKHRAllocator>>::type
+    PhysicalDevice::getDisplayPropertiesKHR( DisplayPropertiesKHRAllocator & displayPropertiesKHRAllocator,
+                                             Dispatch const &                d ) const
+  {
+    std::vector<DisplayPropertiesKHR, DisplayPropertiesKHRAllocator> properties( displayPropertiesKHRAllocator );
+    uint32_t                                                         propertyCount;
+    Result                                                           result;
+    do
+    {
+      result =
+        static_cast<Result>( d.vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && propertyCount )
+      {
+        properties.resize( propertyCount );
+        result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPropertiesKHR(
+          m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPropertiesKHR *>( properties.data() ) ) );
+        VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) )
+    {
+      properties.resize( propertyCount );
+    }
+    return createResultValue(
+      result, properties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPropertiesKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    PhysicalDevice::getDisplayPlanePropertiesKHR( uint32_t *                                        pPropertyCount,
+                                                  VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR * pProperties,
+                                                  Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
+      m_physicalDevice, pPropertyCount, reinterpret_cast<VkDisplayPlanePropertiesKHR *>( pProperties ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename DisplayPlanePropertiesKHRAllocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
+    typename ResultValueType<std::vector<DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator>>::type
+    PhysicalDevice::getDisplayPlanePropertiesKHR( Dispatch const & d ) const
+  {
+    std::vector<DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator> properties;
+    uint32_t                                                                   propertyCount;
+    Result                                                                     result;
+    do
+    {
+      result = static_cast<Result>(
+        d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && propertyCount )
+      {
+        properties.resize( propertyCount );
+        result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
+          m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPlanePropertiesKHR *>( properties.data() ) ) );
+        VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) )
+    {
+      properties.resize( propertyCount );
+    }
+    return createResultValue(
+      result, properties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlanePropertiesKHR" );
+  }
+
+  template <typename DisplayPlanePropertiesKHRAllocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, DisplayPlanePropertiesKHR>::value, int>::type>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
+    typename ResultValueType<std::vector<DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator>>::type
+    PhysicalDevice::getDisplayPlanePropertiesKHR(
+      DisplayPlanePropertiesKHRAllocator & displayPlanePropertiesKHRAllocator, Dispatch const & d ) const
+  {
+    std::vector<DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator> properties(
+      displayPlanePropertiesKHRAllocator );
+    uint32_t propertyCount;
+    Result   result;
+    do
+    {
+      result = static_cast<Result>(
+        d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && propertyCount )
+      {
+        properties.resize( propertyCount );
+        result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
+          m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPlanePropertiesKHR *>( properties.data() ) ) );
+        VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) )
+    {
+      properties.resize( propertyCount );
+    }
+    return createResultValue(
+      result, properties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlanePropertiesKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR( uint32_t                           planeIndex,
+                                                         uint32_t *                         pDisplayCount,
+                                                         VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplays,
+                                                         Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkGetDisplayPlaneSupportedDisplaysKHR(
+      m_physicalDevice, planeIndex, pDisplayCount, reinterpret_cast<VkDisplayKHR *>( pDisplays ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename DisplayKHRAllocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayKHR, DisplayKHRAllocator>>::type
+    PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, Dispatch const & d ) const
+  {
+    std::vector<DisplayKHR, DisplayKHRAllocator> displays;
+    uint32_t                                     displayCount;
+    Result                                       result;
+    do
+    {
+      result = static_cast<Result>(
+        d.vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, &displayCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && displayCount )
+      {
+        displays.resize( displayCount );
+        result = static_cast<Result>( d.vkGetDisplayPlaneSupportedDisplaysKHR(
+          m_physicalDevice, planeIndex, &displayCount, reinterpret_cast<VkDisplayKHR *>( displays.data() ) ) );
+        VULKAN_HPP_ASSERT( displayCount <= displays.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( displayCount < displays.size() ) )
+    {
+      displays.resize( displayCount );
+    }
+    return createResultValue(
+      result, displays, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR" );
+  }
+
+  template <typename DisplayKHRAllocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, DisplayKHR>::value, int>::type>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayKHR, DisplayKHRAllocator>>::type
+                       PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR( uint32_t              planeIndex,
+                                                         DisplayKHRAllocator & displayKHRAllocator,
+                                                         Dispatch const &      d ) const
+  {
+    std::vector<DisplayKHR, DisplayKHRAllocator> displays( displayKHRAllocator );
+    uint32_t                                     displayCount;
+    Result                                       result;
+    do
+    {
+      result = static_cast<Result>(
+        d.vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, &displayCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && displayCount )
+      {
+        displays.resize( displayCount );
+        result = static_cast<Result>( d.vkGetDisplayPlaneSupportedDisplaysKHR(
+          m_physicalDevice, planeIndex, &displayCount, reinterpret_cast<VkDisplayKHR *>( displays.data() ) ) );
+        VULKAN_HPP_ASSERT( displayCount <= displays.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( displayCount < displays.size() ) )
+    {
+      displays.resize( displayCount );
+    }
+    return createResultValue(
+      result, displays, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    PhysicalDevice::getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR                 display,
+                                                 uint32_t *                                       pPropertyCount,
+                                                 VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR * pProperties,
+                                                 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkGetDisplayModePropertiesKHR( m_physicalDevice,
+                                       static_cast<VkDisplayKHR>( display ),
+                                       pPropertyCount,
+                                       reinterpret_cast<VkDisplayModePropertiesKHR *>( pProperties ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename DisplayModePropertiesKHRAllocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
+    typename ResultValueType<std::vector<DisplayModePropertiesKHR, DisplayModePropertiesKHRAllocator>>::type
+    PhysicalDevice::getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d ) const
+  {
+    std::vector<DisplayModePropertiesKHR, DisplayModePropertiesKHRAllocator> properties;
+    uint32_t                                                                 propertyCount;
+    Result                                                                   result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetDisplayModePropertiesKHR(
+        m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && propertyCount )
+      {
+        properties.resize( propertyCount );
+        result = static_cast<Result>(
+          d.vkGetDisplayModePropertiesKHR( m_physicalDevice,
+                                           static_cast<VkDisplayKHR>( display ),
+                                           &propertyCount,
+                                           reinterpret_cast<VkDisplayModePropertiesKHR *>( properties.data() ) ) );
+        VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) )
+    {
+      properties.resize( propertyCount );
+    }
+    return createResultValue(
+      result, properties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayModePropertiesKHR" );
+  }
+
+  template <typename DisplayModePropertiesKHRAllocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, DisplayModePropertiesKHR>::value, int>::type>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
+    typename ResultValueType<std::vector<DisplayModePropertiesKHR, DisplayModePropertiesKHRAllocator>>::type
+    PhysicalDevice::getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR    display,
+                                                 DisplayModePropertiesKHRAllocator & displayModePropertiesKHRAllocator,
+                                                 Dispatch const &                    d ) const
+  {
+    std::vector<DisplayModePropertiesKHR, DisplayModePropertiesKHRAllocator> properties(
+      displayModePropertiesKHRAllocator );
+    uint32_t propertyCount;
+    Result   result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetDisplayModePropertiesKHR(
+        m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && propertyCount )
+      {
+        properties.resize( propertyCount );
+        result = static_cast<Result>(
+          d.vkGetDisplayModePropertiesKHR( m_physicalDevice,
+                                           static_cast<VkDisplayKHR>( display ),
+                                           &propertyCount,
+                                           reinterpret_cast<VkDisplayModePropertiesKHR *>( properties.data() ) ) );
+        VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) )
+    {
+      properties.resize( propertyCount );
+    }
+    return createResultValue(
+      result, properties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayModePropertiesKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    PhysicalDevice::createDisplayModeKHR( VULKAN_HPP_NAMESPACE::DisplayKHR                       display,
+                                          const VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR * pCreateInfo,
+                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks *      pAllocator,
+                                          VULKAN_HPP_NAMESPACE::DisplayModeKHR *                 pMode,
+                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkCreateDisplayModeKHR( m_physicalDevice,
+                                static_cast<VkDisplayKHR>( display ),
+                                reinterpret_cast<const VkDisplayModeCreateInfoKHR *>( pCreateInfo ),
+                                reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
+                                reinterpret_cast<VkDisplayModeKHR *>( pMode ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayModeKHR>::type
+    PhysicalDevice::createDisplayModeKHR( VULKAN_HPP_NAMESPACE::DisplayKHR    display,
+                                          const DisplayModeCreateInfoKHR &    createInfo,
+                                          Optional<const AllocationCallbacks> allocator,
+                                          Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::DisplayModeKHR mode;
+    Result                               result = static_cast<Result>(
+      d.vkCreateDisplayModeKHR( m_physicalDevice,
+                                static_cast<VkDisplayKHR>( display ),
+                                reinterpret_cast<const VkDisplayModeCreateInfoKHR *>( &createInfo ),
+                                reinterpret_cast<const VkAllocationCallbacks *>(
+                                  static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                reinterpret_cast<VkDisplayModeKHR *>( &mode ) ) );
+    return createResultValue( result, mode, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::createDisplayModeKHR" );
+  }
+
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayModeKHR, Dispatch>>::type
+    PhysicalDevice::createDisplayModeKHRUnique( VULKAN_HPP_NAMESPACE::DisplayKHR    display,
+                                                const DisplayModeCreateInfoKHR &    createInfo,
+                                                Optional<const AllocationCallbacks> allocator,
+                                                Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::DisplayModeKHR mode;
+    Result                               result = static_cast<Result>(
+      d.vkCreateDisplayModeKHR( m_physicalDevice,
+                                static_cast<VkDisplayKHR>( display ),
+                                reinterpret_cast<const VkDisplayModeCreateInfoKHR *>( &createInfo ),
+                                reinterpret_cast<const VkAllocationCallbacks *>(
+                                  static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                reinterpret_cast<VkDisplayModeKHR *>( &mode ) ) );
+    ObjectDestroy<PhysicalDevice, Dispatch> deleter( *this, allocator, d );
+    return createResultValue<VULKAN_HPP_NAMESPACE::DisplayModeKHR, Dispatch>(
+      result, mode, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::createDisplayModeKHRUnique", deleter );
+  }
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    PhysicalDevice::getDisplayPlaneCapabilitiesKHR( VULKAN_HPP_NAMESPACE::DisplayModeKHR                mode,
+                                                    uint32_t                                            planeIndex,
+                                                    VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR * pCapabilities,
+                                                    Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkGetDisplayPlaneCapabilitiesKHR( m_physicalDevice,
+                                          static_cast<VkDisplayModeKHR>( mode ),
+                                          planeIndex,
+                                          reinterpret_cast<VkDisplayPlaneCapabilitiesKHR *>( pCapabilities ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR>::type
+    PhysicalDevice::getDisplayPlaneCapabilitiesKHR( VULKAN_HPP_NAMESPACE::DisplayModeKHR mode,
+                                                    uint32_t                             planeIndex,
+                                                    Dispatch const &                     d ) const
+  {
+    VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR capabilities;
+    Result                                            result = static_cast<Result>(
+      d.vkGetDisplayPlaneCapabilitiesKHR( m_physicalDevice,
+                                          static_cast<VkDisplayModeKHR>( mode ),
+                                          planeIndex,
+                                          reinterpret_cast<VkDisplayPlaneCapabilitiesKHR *>( &capabilities ) ) );
+    return createResultValue(
+      result, capabilities, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneCapabilitiesKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Instance::createDisplayPlaneSurfaceKHR( const VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR * pCreateInfo,
+                                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks *         pAllocator,
+                                            VULKAN_HPP_NAMESPACE::SurfaceKHR *                        pSurface,
+                                            Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkCreateDisplayPlaneSurfaceKHR( m_instance,
+                                        reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR *>( pCreateInfo ),
+                                        reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
+                                        reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
+    Instance::createDisplayPlaneSurfaceKHR( const DisplaySurfaceCreateInfoKHR & createInfo,
+                                            Optional<const AllocationCallbacks> allocator,
+                                            Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
+    Result                           result = static_cast<Result>(
+      d.vkCreateDisplayPlaneSurfaceKHR( m_instance,
+                                        reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR *>( &createInfo ),
+                                        reinterpret_cast<const VkAllocationCallbacks *>(
+                                          static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                        reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
+    return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDisplayPlaneSurfaceKHR" );
+  }
+
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
+    Instance::createDisplayPlaneSurfaceKHRUnique( const DisplaySurfaceCreateInfoKHR & createInfo,
+                                                  Optional<const AllocationCallbacks> allocator,
+                                                  Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
+    Result                           result = static_cast<Result>(
+      d.vkCreateDisplayPlaneSurfaceKHR( m_instance,
+                                        reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR *>( &createInfo ),
+                                        reinterpret_cast<const VkAllocationCallbacks *>(
+                                          static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                        reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
+    ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d );
+    return createResultValue<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>(
+      result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDisplayPlaneSurfaceKHRUnique", deleter );
+  }
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  //=== VK_KHR_display_swapchain ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::createSharedSwapchainsKHR( uint32_t                                             swapchainCount,
+                                       const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR * pCreateInfos,
+                                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *    pAllocator,
+                                       VULKAN_HPP_NAMESPACE::SwapchainKHR *                 pSwapchains,
+                                       Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkCreateSharedSwapchainsKHR( m_device,
+                                     swapchainCount,
+                                     reinterpret_cast<const VkSwapchainCreateInfoKHR *>( pCreateInfos ),
+                                     reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
+                                     reinterpret_cast<VkSwapchainKHR *>( pSwapchains ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename SwapchainKHRAllocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<std::vector<SwapchainKHR, SwapchainKHRAllocator>>::type
+    Device::createSharedSwapchainsKHR(
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
+      Optional<const AllocationCallbacks>                                    allocator,
+      Dispatch const &                                                       d ) const
+  {
+    std::vector<SwapchainKHR, SwapchainKHRAllocator> swapchains( createInfos.size() );
+    Result                                           result = static_cast<Result>(
+      d.vkCreateSharedSwapchainsKHR( m_device,
+                                     createInfos.size(),
+                                     reinterpret_cast<const VkSwapchainCreateInfoKHR *>( createInfos.data() ),
+                                     reinterpret_cast<const VkAllocationCallbacks *>(
+                                       static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                     reinterpret_cast<VkSwapchainKHR *>( swapchains.data() ) ) );
+    return createResultValue( result, swapchains, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHR" );
+  }
+
+  template <typename SwapchainKHRAllocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, SwapchainKHR>::value, int>::type>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<std::vector<SwapchainKHR, SwapchainKHRAllocator>>::type
+    Device::createSharedSwapchainsKHR(
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
+      Optional<const AllocationCallbacks>                                    allocator,
+      SwapchainKHRAllocator &                                                swapchainKHRAllocator,
+      Dispatch const &                                                       d ) const
+  {
+    std::vector<SwapchainKHR, SwapchainKHRAllocator> swapchains( createInfos.size(), swapchainKHRAllocator );
+    Result                                           result = static_cast<Result>(
+      d.vkCreateSharedSwapchainsKHR( m_device,
+                                     createInfos.size(),
+                                     reinterpret_cast<const VkSwapchainCreateInfoKHR *>( createInfos.data() ),
+                                     reinterpret_cast<const VkAllocationCallbacks *>(
+                                       static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                     reinterpret_cast<VkSwapchainKHR *>( swapchains.data() ) ) );
+    return createResultValue( result, swapchains, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHR" );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<SwapchainKHR>::type
+    Device::createSharedSwapchainKHR( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR & createInfo,
+                                      Optional<const AllocationCallbacks>                  allocator,
+                                      Dispatch const &                                     d ) const
+  {
+    SwapchainKHR swapchain;
+    Result       result = static_cast<Result>(
+      d.vkCreateSharedSwapchainsKHR( m_device,
+                                     1,
+                                     reinterpret_cast<const VkSwapchainCreateInfoKHR *>( &createInfo ),
+                                     reinterpret_cast<const VkAllocationCallbacks *>(
+                                       static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                     reinterpret_cast<VkSwapchainKHR *>( &swapchain ) ) );
+    return createResultValue( result, swapchain, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainKHR" );
+  }
+
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch, typename SwapchainKHRAllocator>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR, Dispatch>, SwapchainKHRAllocator>>::type
+    Device::createSharedSwapchainsKHRUnique(
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
+      Optional<const AllocationCallbacks>                                    allocator,
+      Dispatch const &                                                       d ) const
+  {
+    std::vector<UniqueHandle<SwapchainKHR, Dispatch>, SwapchainKHRAllocator> uniqueSwapchains;
+    std::vector<SwapchainKHR>                                                swapchains( createInfos.size() );
+    Result                                                                   result = static_cast<Result>(
+      d.vkCreateSharedSwapchainsKHR( m_device,
+                                     createInfos.size(),
+                                     reinterpret_cast<const VkSwapchainCreateInfoKHR *>( createInfos.data() ),
+                                     reinterpret_cast<const VkAllocationCallbacks *>(
+                                       static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                     reinterpret_cast<VkSwapchainKHR *>( swapchains.data() ) ) );
+    if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess )
+    {
+      uniqueSwapchains.reserve( createInfos.size() );
+      ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
+      for ( size_t i = 0; i < createInfos.size(); i++ )
+      {
+        uniqueSwapchains.push_back( UniqueHandle<SwapchainKHR, Dispatch>( swapchains[i], deleter ) );
+      }
+    }
+    return createResultValue(
+      result, std::move( uniqueSwapchains ), VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHRUnique" );
+  }
+
+  template <typename Dispatch,
+            typename SwapchainKHRAllocator,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<SwapchainKHR, Dispatch>>::value,
+                                    int>::type>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR, Dispatch>, SwapchainKHRAllocator>>::type
+    Device::createSharedSwapchainsKHRUnique(
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
+      Optional<const AllocationCallbacks>                                    allocator,
+      SwapchainKHRAllocator &                                                swapchainKHRAllocator,
+      Dispatch const &                                                       d ) const
+  {
+    std::vector<UniqueHandle<SwapchainKHR, Dispatch>, SwapchainKHRAllocator> uniqueSwapchains( swapchainKHRAllocator );
+    std::vector<SwapchainKHR>                                                swapchains( createInfos.size() );
+    Result                                                                   result = static_cast<Result>(
+      d.vkCreateSharedSwapchainsKHR( m_device,
+                                     createInfos.size(),
+                                     reinterpret_cast<const VkSwapchainCreateInfoKHR *>( createInfos.data() ),
+                                     reinterpret_cast<const VkAllocationCallbacks *>(
+                                       static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                     reinterpret_cast<VkSwapchainKHR *>( swapchains.data() ) ) );
+    if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess )
+    {
+      uniqueSwapchains.reserve( createInfos.size() );
+      ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
+      for ( size_t i = 0; i < createInfos.size(); i++ )
+      {
+        uniqueSwapchains.push_back( UniqueHandle<SwapchainKHR, Dispatch>( swapchains[i], deleter ) );
+      }
+    }
+    return createResultValue(
+      result, std::move( uniqueSwapchains ), VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHRUnique" );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<UniqueHandle<SwapchainKHR, Dispatch>>::type
+    Device::createSharedSwapchainKHRUnique( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR & createInfo,
+                                            Optional<const AllocationCallbacks>                  allocator,
+                                            Dispatch const &                                     d ) const
+  {
+    SwapchainKHR swapchain;
+    Result       result = static_cast<Result>(
+      d.vkCreateSharedSwapchainsKHR( m_device,
+                                     1,
+                                     reinterpret_cast<const VkSwapchainCreateInfoKHR *>( &createInfo ),
+                                     reinterpret_cast<const VkAllocationCallbacks *>(
+                                       static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                     reinterpret_cast<VkSwapchainKHR *>( &swapchain ) ) );
+    ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
+    return createResultValue<SwapchainKHR, Dispatch>(
+      result, swapchain, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainKHRUnique", deleter );
+  }
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#if defined( VK_USE_PLATFORM_XLIB_KHR )
+  //=== VK_KHR_xlib_surface ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Instance::createXlibSurfaceKHR( const VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR * pCreateInfo,
+                                    const VULKAN_HPP_NAMESPACE::AllocationCallbacks *      pAllocator,
+                                    VULKAN_HPP_NAMESPACE::SurfaceKHR *                     pSurface,
+                                    Dispatch const &                                       d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkCreateXlibSurfaceKHR( m_instance,
+                                reinterpret_cast<const VkXlibSurfaceCreateInfoKHR *>( pCreateInfo ),
+                                reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
+                                reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
+  }
+
+#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
+    Instance::createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR &    createInfo,
+                                    Optional<const AllocationCallbacks> allocator,
+                                    Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
+    Result                           result = static_cast<Result>(
+      d.vkCreateXlibSurfaceKHR( m_instance,
+                                reinterpret_cast<const VkXlibSurfaceCreateInfoKHR *>( &createInfo ),
+                                reinterpret_cast<const VkAllocationCallbacks *>(
+                                  static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
+    return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createXlibSurfaceKHR" );
+  }
+
+#    ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
+    Instance::createXlibSurfaceKHRUnique( const XlibSurfaceCreateInfoKHR &    createInfo,
+                                          Optional<const AllocationCallbacks> allocator,
+                                          Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
+    Result                           result = static_cast<Result>(
+      d.vkCreateXlibSurfaceKHR( m_instance,
+                                reinterpret_cast<const VkXlibSurfaceCreateInfoKHR *>( &createInfo ),
+                                reinterpret_cast<const VkAllocationCallbacks *>(
+                                  static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
+    ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d );
+    return createResultValue<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>(
+      result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createXlibSurfaceKHRUnique", deleter );
+  }
+#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXlibPresentationSupportKHR( uint32_t         queueFamilyIndex,
+                                                                          Display *        dpy,
+                                                                          VisualID         visualID,
+                                                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Bool32>(
+      d.vkGetPhysicalDeviceXlibPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, dpy, visualID ) );
+  }
+
+#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXlibPresentationSupportKHR( uint32_t         queueFamilyIndex,
+                                                                          Display &        dpy,
+                                                                          VisualID         visualID,
+                                                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return d.vkGetPhysicalDeviceXlibPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &dpy, visualID );
+  }
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VK_USE_PLATFORM_XLIB_KHR*/
+
+#if defined( VK_USE_PLATFORM_XCB_KHR )
+  //=== VK_KHR_xcb_surface ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Instance::createXcbSurfaceKHR( const VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR * pCreateInfo,
+                                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks *     pAllocator,
+                                   VULKAN_HPP_NAMESPACE::SurfaceKHR *                    pSurface,
+                                   Dispatch const &                                      d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkCreateXcbSurfaceKHR( m_instance,
+                               reinterpret_cast<const VkXcbSurfaceCreateInfoKHR *>( pCreateInfo ),
+                               reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
+                               reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
+  }
+
+#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
+    Instance::createXcbSurfaceKHR( const XcbSurfaceCreateInfoKHR &     createInfo,
+                                   Optional<const AllocationCallbacks> allocator,
+                                   Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
+    Result                           result = static_cast<Result>(
+      d.vkCreateXcbSurfaceKHR( m_instance,
+                               reinterpret_cast<const VkXcbSurfaceCreateInfoKHR *>( &createInfo ),
+                               reinterpret_cast<const VkAllocationCallbacks *>(
+                                 static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                               reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
+    return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createXcbSurfaceKHR" );
+  }
+
+#    ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
+    Instance::createXcbSurfaceKHRUnique( const XcbSurfaceCreateInfoKHR &     createInfo,
+                                         Optional<const AllocationCallbacks> allocator,
+                                         Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
+    Result                           result = static_cast<Result>(
+      d.vkCreateXcbSurfaceKHR( m_instance,
+                               reinterpret_cast<const VkXcbSurfaceCreateInfoKHR *>( &createInfo ),
+                               reinterpret_cast<const VkAllocationCallbacks *>(
+                                 static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                               reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
+    ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d );
+    return createResultValue<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>(
+      result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createXcbSurfaceKHRUnique", deleter );
+  }
+#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXcbPresentationSupportKHR( uint32_t           queueFamilyIndex,
+                                                                         xcb_connection_t * connection,
+                                                                         xcb_visualid_t     visual_id,
+                                                                         Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Bool32>(
+      d.vkGetPhysicalDeviceXcbPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, connection, visual_id ) );
+  }
+
+#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXcbPresentationSupportKHR( uint32_t           queueFamilyIndex,
+                                                                         xcb_connection_t & connection,
+                                                                         xcb_visualid_t     visual_id,
+                                                                         Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return d.vkGetPhysicalDeviceXcbPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &connection, visual_id );
+  }
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VK_USE_PLATFORM_XCB_KHR*/
+
+#if defined( VK_USE_PLATFORM_WAYLAND_KHR )
+  //=== VK_KHR_wayland_surface ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Instance::createWaylandSurfaceKHR( const VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR * pCreateInfo,
+                                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *         pAllocator,
+                                       VULKAN_HPP_NAMESPACE::SurfaceKHR *                        pSurface,
+                                       Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkCreateWaylandSurfaceKHR( m_instance,
+                                   reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR *>( pCreateInfo ),
+                                   reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
+                                   reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
+  }
+
+#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
+    Instance::createWaylandSurfaceKHR( const WaylandSurfaceCreateInfoKHR & createInfo,
+                                       Optional<const AllocationCallbacks> allocator,
+                                       Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
+    Result                           result = static_cast<Result>(
+      d.vkCreateWaylandSurfaceKHR( m_instance,
+                                   reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR *>( &createInfo ),
+                                   reinterpret_cast<const VkAllocationCallbacks *>(
+                                     static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                   reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
+    return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createWaylandSurfaceKHR" );
+  }
+
+#    ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
+    Instance::createWaylandSurfaceKHRUnique( const WaylandSurfaceCreateInfoKHR & createInfo,
+                                             Optional<const AllocationCallbacks> allocator,
+                                             Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
+    Result                           result = static_cast<Result>(
+      d.vkCreateWaylandSurfaceKHR( m_instance,
+                                   reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR *>( &createInfo ),
+                                   reinterpret_cast<const VkAllocationCallbacks *>(
+                                     static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                   reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
+    ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d );
+    return createResultValue<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>(
+      result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createWaylandSurfaceKHRUnique", deleter );
+  }
+#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE Bool32 PhysicalDevice::getWaylandPresentationSupportKHR(
+    uint32_t queueFamilyIndex, struct wl_display * display, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Bool32>(
+      d.vkGetPhysicalDeviceWaylandPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, display ) );
+  }
+
+#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE Bool32 PhysicalDevice::getWaylandPresentationSupportKHR(
+    uint32_t queueFamilyIndex, struct wl_display & display, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return d.vkGetPhysicalDeviceWaylandPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &display );
+  }
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VK_USE_PLATFORM_WAYLAND_KHR*/
+
+#if defined( VK_USE_PLATFORM_ANDROID_KHR )
+  //=== VK_KHR_android_surface ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Instance::createAndroidSurfaceKHR( const VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR * pCreateInfo,
+                                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *         pAllocator,
+                                       VULKAN_HPP_NAMESPACE::SurfaceKHR *                        pSurface,
+                                       Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkCreateAndroidSurfaceKHR( m_instance,
+                                   reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR *>( pCreateInfo ),
+                                   reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
+                                   reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
+  }
+
+#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
+    Instance::createAndroidSurfaceKHR( const AndroidSurfaceCreateInfoKHR & createInfo,
+                                       Optional<const AllocationCallbacks> allocator,
+                                       Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
+    Result                           result = static_cast<Result>(
+      d.vkCreateAndroidSurfaceKHR( m_instance,
+                                   reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR *>( &createInfo ),
+                                   reinterpret_cast<const VkAllocationCallbacks *>(
+                                     static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                   reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
+    return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createAndroidSurfaceKHR" );
+  }
+
+#    ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
+    Instance::createAndroidSurfaceKHRUnique( const AndroidSurfaceCreateInfoKHR & createInfo,
+                                             Optional<const AllocationCallbacks> allocator,
+                                             Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
+    Result                           result = static_cast<Result>(
+      d.vkCreateAndroidSurfaceKHR( m_instance,
+                                   reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR *>( &createInfo ),
+                                   reinterpret_cast<const VkAllocationCallbacks *>(
+                                     static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                   reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
+    ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d );
+    return createResultValue<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>(
+      result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createAndroidSurfaceKHRUnique", deleter );
+  }
+#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif     /*VK_USE_PLATFORM_ANDROID_KHR*/
+
+#if defined( VK_USE_PLATFORM_WIN32_KHR )
+  //=== VK_KHR_win32_surface ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Instance::createWin32SurfaceKHR( const VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR * pCreateInfo,
+                                     const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,
+                                     VULKAN_HPP_NAMESPACE::SurfaceKHR *                      pSurface,
+                                     Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkCreateWin32SurfaceKHR( m_instance,
+                                 reinterpret_cast<const VkWin32SurfaceCreateInfoKHR *>( pCreateInfo ),
+                                 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
+                                 reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
+  }
+
+#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
+    Instance::createWin32SurfaceKHR( const Win32SurfaceCreateInfoKHR &   createInfo,
+                                     Optional<const AllocationCallbacks> allocator,
+                                     Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
+    Result                           result = static_cast<Result>(
+      d.vkCreateWin32SurfaceKHR( m_instance,
+                                 reinterpret_cast<const VkWin32SurfaceCreateInfoKHR *>( &createInfo ),
+                                 reinterpret_cast<const VkAllocationCallbacks *>(
+                                   static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
+    return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createWin32SurfaceKHR" );
+  }
+
+#    ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
+    Instance::createWin32SurfaceKHRUnique( const Win32SurfaceCreateInfoKHR &   createInfo,
+                                           Optional<const AllocationCallbacks> allocator,
+                                           Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
+    Result                           result = static_cast<Result>(
+      d.vkCreateWin32SurfaceKHR( m_instance,
+                                 reinterpret_cast<const VkWin32SurfaceCreateInfoKHR *>( &createInfo ),
+                                 reinterpret_cast<const VkAllocationCallbacks *>(
+                                   static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
+    ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d );
+    return createResultValue<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>(
+      result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createWin32SurfaceKHRUnique", deleter );
+  }
+#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE Bool32 PhysicalDevice::getWin32PresentationSupportKHR(
+    uint32_t queueFamilyIndex, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Bool32>(
+      d.vkGetPhysicalDeviceWin32PresentationSupportKHR( m_physicalDevice, queueFamilyIndex ) );
+  }
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+  //=== VK_EXT_debug_report ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Instance::createDebugReportCallbackEXT( const VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT * pCreateInfo,
+                                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks *              pAllocator,
+                                            VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT *                 pCallback,
+                                            Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkCreateDebugReportCallbackEXT( m_instance,
+                                        reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT *>( pCreateInfo ),
+                                        reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
+                                        reinterpret_cast<VkDebugReportCallbackEXT *>( pCallback ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT>::type
+    Instance::createDebugReportCallbackEXT( const DebugReportCallbackCreateInfoEXT & createInfo,
+                                            Optional<const AllocationCallbacks>      allocator,
+                                            Dispatch const &                         d ) const
+  {
+    VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback;
+    Result                                       result = static_cast<Result>(
+      d.vkCreateDebugReportCallbackEXT( m_instance,
+                                        reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT *>( &createInfo ),
+                                        reinterpret_cast<const VkAllocationCallbacks *>(
+                                          static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                        reinterpret_cast<VkDebugReportCallbackEXT *>( &callback ) ) );
+    return createResultValue(
+      result, callback, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDebugReportCallbackEXT" );
+  }
+
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT, Dispatch>>::type
+    Instance::createDebugReportCallbackEXTUnique( const DebugReportCallbackCreateInfoEXT & createInfo,
+                                                  Optional<const AllocationCallbacks>      allocator,
+                                                  Dispatch const &                         d ) const
+  {
+    VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback;
+    Result                                       result = static_cast<Result>(
+      d.vkCreateDebugReportCallbackEXT( m_instance,
+                                        reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT *>( &createInfo ),
+                                        reinterpret_cast<const VkAllocationCallbacks *>(
+                                          static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                        reinterpret_cast<VkDebugReportCallbackEXT *>( &callback ) ) );
+    ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d );
+    return createResultValue<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT, Dispatch>(
+      result, callback, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDebugReportCallbackEXTUnique", deleter );
+  }
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    Instance::destroyDebugReportCallbackEXT( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT      callback,
+                                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                             Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyDebugReportCallbackEXT( m_instance,
+                                       static_cast<VkDebugReportCallbackEXT>( callback ),
+                                       reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Instance::destroyDebugReportCallbackEXT( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback,
+                                                                  Optional<const AllocationCallbacks> allocator,
+                                                                  Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyDebugReportCallbackEXT(
+      m_instance,
+      static_cast<VkDebugReportCallbackEXT>( callback ),
+      reinterpret_cast<const VkAllocationCallbacks *>(
+        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Instance::destroy( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT      callback,
+                                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                            Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyDebugReportCallbackEXT( m_instance,
+                                       static_cast<VkDebugReportCallbackEXT>( callback ),
+                                       reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Instance::destroy( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback,
+                                            Optional<const AllocationCallbacks>          allocator,
+                                            Dispatch const &                             d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyDebugReportCallbackEXT(
+      m_instance,
+      static_cast<VkDebugReportCallbackEXT>( callback ),
+      reinterpret_cast<const VkAllocationCallbacks *>(
+        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Instance::debugReportMessageEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT      flags,
+                                                          VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType,
+                                                          uint64_t                                       object,
+                                                          size_t                                         location,
+                                                          int32_t                                        messageCode,
+                                                          const char *                                   pLayerPrefix,
+                                                          const char *                                   pMessage,
+                                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDebugReportMessageEXT( m_instance,
+                               static_cast<VkDebugReportFlagsEXT>( flags ),
+                               static_cast<VkDebugReportObjectTypeEXT>( objectType ),
+                               object,
+                               location,
+                               messageCode,
+                               pLayerPrefix,
+                               pMessage );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Instance::debugReportMessageEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT      flags,
+                                                          VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType,
+                                                          uint64_t                                       object,
+                                                          size_t                                         location,
+                                                          int32_t                                        messageCode,
+                                                          const std::string &                            layerPrefix,
+                                                          const std::string &                            message,
+                                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDebugReportMessageEXT( m_instance,
+                               static_cast<VkDebugReportFlagsEXT>( flags ),
+                               static_cast<VkDebugReportObjectTypeEXT>( objectType ),
+                               object,
+                               location,
+                               messageCode,
+                               layerPrefix.c_str(),
+                               message.c_str() );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  //=== VK_EXT_debug_marker ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::debugMarkerSetObjectTagEXT(
+    const VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT * pTagInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkDebugMarkerSetObjectTagEXT( m_device, reinterpret_cast<const VkDebugMarkerObjectTagInfoEXT *>( pTagInfo ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
+    Device::debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT & tagInfo, Dispatch const & d ) const
+  {
+    Result result = static_cast<Result>(
+      d.vkDebugMarkerSetObjectTagEXT( m_device, reinterpret_cast<const VkDebugMarkerObjectTagInfoEXT *>( &tagInfo ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::debugMarkerSetObjectTagEXT" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::debugMarkerSetObjectNameEXT(
+    const VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT * pNameInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkDebugMarkerSetObjectNameEXT(
+      m_device, reinterpret_cast<const VkDebugMarkerObjectNameInfoEXT *>( pNameInfo ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
+    Device::debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT & nameInfo, Dispatch const & d ) const
+  {
+    Result result = static_cast<Result>( d.vkDebugMarkerSetObjectNameEXT(
+      m_device, reinterpret_cast<const VkDebugMarkerObjectNameInfoEXT *>( &nameInfo ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::debugMarkerSetObjectNameEXT" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    CommandBuffer::debugMarkerBeginEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT * pMarkerInfo,
+                                        Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdDebugMarkerBeginEXT( m_commandBuffer, reinterpret_cast<const VkDebugMarkerMarkerInfoEXT *>( pMarkerInfo ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT & markerInfo,
+                                                             Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdDebugMarkerBeginEXT( m_commandBuffer, reinterpret_cast<const VkDebugMarkerMarkerInfoEXT *>( &markerInfo ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::debugMarkerEndEXT( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdDebugMarkerEndEXT( m_commandBuffer );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    CommandBuffer::debugMarkerInsertEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT * pMarkerInfo,
+                                         Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdDebugMarkerInsertEXT( m_commandBuffer, reinterpret_cast<const VkDebugMarkerMarkerInfoEXT *>( pMarkerInfo ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::debugMarkerInsertEXT( const DebugMarkerMarkerInfoEXT & markerInfo,
+                                                              Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdDebugMarkerInsertEXT( m_commandBuffer, reinterpret_cast<const VkDebugMarkerMarkerInfoEXT *>( &markerInfo ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#if defined( VK_ENABLE_BETA_EXTENSIONS )
+  //=== VK_KHR_video_queue ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    PhysicalDevice::getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileKHR * pVideoProfile,
+                                             VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR *  pCapabilities,
+                                             Dispatch const &                              d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkGetPhysicalDeviceVideoCapabilitiesKHR( m_physicalDevice,
+                                                 reinterpret_cast<const VkVideoProfileKHR *>( pVideoProfile ),
+                                                 reinterpret_cast<VkVideoCapabilitiesKHR *>( pCapabilities ) ) );
+  }
+
+#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR>::type
+    PhysicalDevice::getVideoCapabilitiesKHR( const VideoProfileKHR & videoProfile, Dispatch const & d ) const
+  {
+    VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR capabilities;
+    Result                                     result = static_cast<Result>(
+      d.vkGetPhysicalDeviceVideoCapabilitiesKHR( m_physicalDevice,
+                                                 reinterpret_cast<const VkVideoProfileKHR *>( &videoProfile ),
+                                                 reinterpret_cast<VkVideoCapabilitiesKHR *>( &capabilities ) ) );
+    return createResultValue(
+      result, capabilities, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoCapabilitiesKHR" );
+  }
+
+  template <typename X, typename Y, typename... Z, typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<StructureChain<X, Y, Z...>>::type
+    PhysicalDevice::getVideoCapabilitiesKHR( const VideoProfileKHR & videoProfile, Dispatch const & d ) const
+  {
+    StructureChain<X, Y, Z...>                   structureChain;
+    VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR & capabilities =
+      structureChain.template get<VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR>();
+    Result result = static_cast<Result>(
+      d.vkGetPhysicalDeviceVideoCapabilitiesKHR( m_physicalDevice,
+                                                 reinterpret_cast<const VkVideoProfileKHR *>( &videoProfile ),
+                                                 reinterpret_cast<VkVideoCapabilitiesKHR *>( &capabilities ) ) );
+    return createResultValue(
+      result, structureChain, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoCapabilitiesKHR" );
+  }
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getVideoFormatPropertiesKHR(
+    const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR * pVideoFormatInfo,
+    uint32_t *                                                     pVideoFormatPropertyCount,
+    VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR *               pVideoFormatProperties,
+    Dispatch const &                                               d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkGetPhysicalDeviceVideoFormatPropertiesKHR(
+      m_physicalDevice,
+      reinterpret_cast<const VkPhysicalDeviceVideoFormatInfoKHR *>( pVideoFormatInfo ),
+      pVideoFormatPropertyCount,
+      reinterpret_cast<VkVideoFormatPropertiesKHR *>( pVideoFormatProperties ) ) );
+  }
+
+#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename VideoFormatPropertiesKHRAllocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
+    typename ResultValueType<std::vector<VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator>>::type
+    PhysicalDevice::getVideoFormatPropertiesKHR( const PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo,
+                                                 Dispatch const &                         d ) const
+  {
+    std::vector<VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator> videoFormatProperties;
+    uint32_t                                                                 videoFormatPropertyCount;
+    Result                                                                   result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetPhysicalDeviceVideoFormatPropertiesKHR(
+        m_physicalDevice,
+        reinterpret_cast<const VkPhysicalDeviceVideoFormatInfoKHR *>( &videoFormatInfo ),
+        &videoFormatPropertyCount,
+        nullptr ) );
+      if ( ( result == Result::eSuccess ) && videoFormatPropertyCount )
+      {
+        videoFormatProperties.resize( videoFormatPropertyCount );
+        result = static_cast<Result>( d.vkGetPhysicalDeviceVideoFormatPropertiesKHR(
+          m_physicalDevice,
+          reinterpret_cast<const VkPhysicalDeviceVideoFormatInfoKHR *>( &videoFormatInfo ),
+          &videoFormatPropertyCount,
+          reinterpret_cast<VkVideoFormatPropertiesKHR *>( videoFormatProperties.data() ) ) );
+        VULKAN_HPP_ASSERT( videoFormatPropertyCount <= videoFormatProperties.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( videoFormatPropertyCount < videoFormatProperties.size() ) )
+    {
+      videoFormatProperties.resize( videoFormatPropertyCount );
+    }
+    return createResultValue(
+      result, videoFormatProperties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoFormatPropertiesKHR" );
+  }
+
+  template <typename VideoFormatPropertiesKHRAllocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, VideoFormatPropertiesKHR>::value, int>::type>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
+    typename ResultValueType<std::vector<VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator>>::type
+    PhysicalDevice::getVideoFormatPropertiesKHR( const PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo,
+                                                 VideoFormatPropertiesKHRAllocator & videoFormatPropertiesKHRAllocator,
+                                                 Dispatch const &                    d ) const
+  {
+    std::vector<VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator> videoFormatProperties(
+      videoFormatPropertiesKHRAllocator );
+    uint32_t videoFormatPropertyCount;
+    Result   result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetPhysicalDeviceVideoFormatPropertiesKHR(
+        m_physicalDevice,
+        reinterpret_cast<const VkPhysicalDeviceVideoFormatInfoKHR *>( &videoFormatInfo ),
+        &videoFormatPropertyCount,
+        nullptr ) );
+      if ( ( result == Result::eSuccess ) && videoFormatPropertyCount )
+      {
+        videoFormatProperties.resize( videoFormatPropertyCount );
+        result = static_cast<Result>( d.vkGetPhysicalDeviceVideoFormatPropertiesKHR(
+          m_physicalDevice,
+          reinterpret_cast<const VkPhysicalDeviceVideoFormatInfoKHR *>( &videoFormatInfo ),
+          &videoFormatPropertyCount,
+          reinterpret_cast<VkVideoFormatPropertiesKHR *>( videoFormatProperties.data() ) ) );
+        VULKAN_HPP_ASSERT( videoFormatPropertyCount <= videoFormatProperties.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( videoFormatPropertyCount < videoFormatProperties.size() ) )
+    {
+      videoFormatProperties.resize( videoFormatPropertyCount );
+    }
+    return createResultValue(
+      result, videoFormatProperties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoFormatPropertiesKHR" );
+  }
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::createVideoSessionKHR( const VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR * pCreateInfo,
+                                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,
+                                   VULKAN_HPP_NAMESPACE::VideoSessionKHR *                 pVideoSession,
+                                   Dispatch const &                                        d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkCreateVideoSessionKHR( m_device,
+                                 reinterpret_cast<const VkVideoSessionCreateInfoKHR *>( pCreateInfo ),
+                                 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
+                                 reinterpret_cast<VkVideoSessionKHR *>( pVideoSession ) ) );
+  }
+
+#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoSessionKHR>::type
+    Device::createVideoSessionKHR( const VideoSessionCreateInfoKHR &   createInfo,
+                                   Optional<const AllocationCallbacks> allocator,
+                                   Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession;
+    Result                                result = static_cast<Result>(
+      d.vkCreateVideoSessionKHR( m_device,
+                                 reinterpret_cast<const VkVideoSessionCreateInfoKHR *>( &createInfo ),
+                                 reinterpret_cast<const VkAllocationCallbacks *>(
+                                   static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                 reinterpret_cast<VkVideoSessionKHR *>( &videoSession ) ) );
+    return createResultValue( result, videoSession, VULKAN_HPP_NAMESPACE_STRING "::Device::createVideoSessionKHR" );
+  }
+
+#    ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::VideoSessionKHR, Dispatch>>::type
+    Device::createVideoSessionKHRUnique( const VideoSessionCreateInfoKHR &   createInfo,
+                                         Optional<const AllocationCallbacks> allocator,
+                                         Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession;
+    Result                                result = static_cast<Result>(
+      d.vkCreateVideoSessionKHR( m_device,
+                                 reinterpret_cast<const VkVideoSessionCreateInfoKHR *>( &createInfo ),
+                                 reinterpret_cast<const VkAllocationCallbacks *>(
+                                   static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                 reinterpret_cast<VkVideoSessionKHR *>( &videoSession ) ) );
+    ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
+    return createResultValue<VULKAN_HPP_NAMESPACE::VideoSessionKHR, Dispatch>(
+      result, videoSession, VULKAN_HPP_NAMESPACE_STRING "::Device::createVideoSessionKHRUnique", deleter );
+  }
+#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyVideoSessionKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR             videoSession,
+                                                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                                         Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyVideoSessionKHR( m_device,
+                                static_cast<VkVideoSessionKHR>( videoSession ),
+                                reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyVideoSessionKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession,
+                                                         Optional<const AllocationCallbacks>   allocator,
+                                                         Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyVideoSessionKHR( m_device,
+                                static_cast<VkVideoSessionKHR>( videoSession ),
+                                reinterpret_cast<const VkAllocationCallbacks *>(
+                                  static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::VideoSessionKHR             videoSession,
+                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyVideoSessionKHR( m_device,
+                                static_cast<VkVideoSessionKHR>( videoSession ),
+                                reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession,
+                                          Optional<const AllocationCallbacks>   allocator,
+                                          Dispatch const &                      d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyVideoSessionKHR( m_device,
+                                static_cast<VkVideoSessionKHR>( videoSession ),
+                                reinterpret_cast<const VkAllocationCallbacks *>(
+                                  static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getVideoSessionMemoryRequirementsKHR(
+    VULKAN_HPP_NAMESPACE::VideoSessionKHR               videoSession,
+    uint32_t *                                          pVideoSessionMemoryRequirementsCount,
+    VULKAN_HPP_NAMESPACE::VideoGetMemoryPropertiesKHR * pVideoSessionMemoryRequirements,
+    Dispatch const &                                    d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkGetVideoSessionMemoryRequirementsKHR(
+      m_device,
+      static_cast<VkVideoSessionKHR>( videoSession ),
+      pVideoSessionMemoryRequirementsCount,
+      reinterpret_cast<VkVideoGetMemoryPropertiesKHR *>( pVideoSessionMemoryRequirements ) ) );
+  }
+
+#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename VideoGetMemoryPropertiesKHRAllocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
+    typename ResultValueType<std::vector<VideoGetMemoryPropertiesKHR, VideoGetMemoryPropertiesKHRAllocator>>::type
+    Device::getVideoSessionMemoryRequirementsKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession,
+                                                  Dispatch const &                      d ) const
+  {
+    std::vector<VideoGetMemoryPropertiesKHR, VideoGetMemoryPropertiesKHRAllocator> videoSessionMemoryRequirements;
+    uint32_t                                                                       videoSessionMemoryRequirementsCount;
+    Result                                                                         result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetVideoSessionMemoryRequirementsKHR(
+        m_device, static_cast<VkVideoSessionKHR>( videoSession ), &videoSessionMemoryRequirementsCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && videoSessionMemoryRequirementsCount )
+      {
+        videoSessionMemoryRequirements.resize( videoSessionMemoryRequirementsCount );
+        result = static_cast<Result>( d.vkGetVideoSessionMemoryRequirementsKHR(
+          m_device,
+          static_cast<VkVideoSessionKHR>( videoSession ),
+          &videoSessionMemoryRequirementsCount,
+          reinterpret_cast<VkVideoGetMemoryPropertiesKHR *>( videoSessionMemoryRequirements.data() ) ) );
+        VULKAN_HPP_ASSERT( videoSessionMemoryRequirementsCount <= videoSessionMemoryRequirements.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) &&
+         ( videoSessionMemoryRequirementsCount < videoSessionMemoryRequirements.size() ) )
+    {
+      videoSessionMemoryRequirements.resize( videoSessionMemoryRequirementsCount );
+    }
+    return createResultValue( result,
+                              videoSessionMemoryRequirements,
+                              VULKAN_HPP_NAMESPACE_STRING "::Device::getVideoSessionMemoryRequirementsKHR" );
+  }
+
+  template <
+    typename VideoGetMemoryPropertiesKHRAllocator,
+    typename Dispatch,
+    typename B,
+    typename std::enable_if<std::is_same<typename B::value_type, VideoGetMemoryPropertiesKHR>::value, int>::type>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
+    typename ResultValueType<std::vector<VideoGetMemoryPropertiesKHR, VideoGetMemoryPropertiesKHRAllocator>>::type
+    Device::getVideoSessionMemoryRequirementsKHR(
+      VULKAN_HPP_NAMESPACE::VideoSessionKHR  videoSession,
+      VideoGetMemoryPropertiesKHRAllocator & videoGetMemoryPropertiesKHRAllocator,
+      Dispatch const &                       d ) const
+  {
+    std::vector<VideoGetMemoryPropertiesKHR, VideoGetMemoryPropertiesKHRAllocator> videoSessionMemoryRequirements(
+      videoGetMemoryPropertiesKHRAllocator );
+    uint32_t videoSessionMemoryRequirementsCount;
+    Result   result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetVideoSessionMemoryRequirementsKHR(
+        m_device, static_cast<VkVideoSessionKHR>( videoSession ), &videoSessionMemoryRequirementsCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && videoSessionMemoryRequirementsCount )
+      {
+        videoSessionMemoryRequirements.resize( videoSessionMemoryRequirementsCount );
+        result = static_cast<Result>( d.vkGetVideoSessionMemoryRequirementsKHR(
+          m_device,
+          static_cast<VkVideoSessionKHR>( videoSession ),
+          &videoSessionMemoryRequirementsCount,
+          reinterpret_cast<VkVideoGetMemoryPropertiesKHR *>( videoSessionMemoryRequirements.data() ) ) );
+        VULKAN_HPP_ASSERT( videoSessionMemoryRequirementsCount <= videoSessionMemoryRequirements.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) &&
+         ( videoSessionMemoryRequirementsCount < videoSessionMemoryRequirements.size() ) )
+    {
+      videoSessionMemoryRequirements.resize( videoSessionMemoryRequirementsCount );
+    }
+    return createResultValue( result,
+                              videoSessionMemoryRequirements,
+                              VULKAN_HPP_NAMESPACE_STRING "::Device::getVideoSessionMemoryRequirementsKHR" );
+  }
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::bindVideoSessionMemoryKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR            videoSession,
+                                       uint32_t                                         videoSessionBindMemoryCount,
+                                       const VULKAN_HPP_NAMESPACE::VideoBindMemoryKHR * pVideoSessionBindMemories,
+                                       Dispatch const &                                 d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkBindVideoSessionMemoryKHR( m_device,
+                                     static_cast<VkVideoSessionKHR>( videoSession ),
+                                     videoSessionBindMemoryCount,
+                                     reinterpret_cast<const VkVideoBindMemoryKHR *>( pVideoSessionBindMemories ) ) );
+  }
+
+#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
+                                          Device::bindVideoSessionMemoryKHR(
+      VULKAN_HPP_NAMESPACE::VideoSessionKHR                              videoSession,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::VideoBindMemoryKHR> const & videoSessionBindMemories,
+      Dispatch const &                                                   d ) const
+  {
+    Result result = static_cast<Result>( d.vkBindVideoSessionMemoryKHR(
+      m_device,
+      static_cast<VkVideoSessionKHR>( videoSession ),
+      videoSessionBindMemories.size(),
+      reinterpret_cast<const VkVideoBindMemoryKHR *>( videoSessionBindMemories.data() ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindVideoSessionMemoryKHR" );
+  }
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createVideoSessionParametersKHR(
+    const VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR * pCreateInfo,
+    const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                 pAllocator,
+    VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR *                 pVideoSessionParameters,
+    Dispatch const &                                                  d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkCreateVideoSessionParametersKHR(
+      m_device,
+      reinterpret_cast<const VkVideoSessionParametersCreateInfoKHR *>( pCreateInfo ),
+      reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
+      reinterpret_cast<VkVideoSessionParametersKHR *>( pVideoSessionParameters ) ) );
+  }
+
+#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR>::type
+    Device::createVideoSessionParametersKHR( const VideoSessionParametersCreateInfoKHR & createInfo,
+                                             Optional<const AllocationCallbacks>         allocator,
+                                             Dispatch const &                            d ) const
+  {
+    VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters;
+    Result                                          result = static_cast<Result>( d.vkCreateVideoSessionParametersKHR(
+      m_device,
+      reinterpret_cast<const VkVideoSessionParametersCreateInfoKHR *>( &createInfo ),
+      reinterpret_cast<const VkAllocationCallbacks *>(
+        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+      reinterpret_cast<VkVideoSessionParametersKHR *>( &videoSessionParameters ) ) );
+    return createResultValue(
+      result, videoSessionParameters, VULKAN_HPP_NAMESPACE_STRING "::Device::createVideoSessionParametersKHR" );
+  }
+
+#    ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR, Dispatch>>::type
+    Device::createVideoSessionParametersKHRUnique( const VideoSessionParametersCreateInfoKHR & createInfo,
+                                                   Optional<const AllocationCallbacks>         allocator,
+                                                   Dispatch const &                            d ) const
+  {
+    VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters;
+    Result                                          result = static_cast<Result>( d.vkCreateVideoSessionParametersKHR(
+      m_device,
+      reinterpret_cast<const VkVideoSessionParametersCreateInfoKHR *>( &createInfo ),
+      reinterpret_cast<const VkAllocationCallbacks *>(
+        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+      reinterpret_cast<VkVideoSessionParametersKHR *>( &videoSessionParameters ) ) );
+    ObjectDestroy<Device, Dispatch>                 deleter( *this, allocator, d );
+    return createResultValue<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR, Dispatch>(
+      result,
+      videoSessionParameters,
+      VULKAN_HPP_NAMESPACE_STRING "::Device::createVideoSessionParametersKHRUnique",
+      deleter );
+  }
+#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::updateVideoSessionParametersKHR(
+    VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR                   videoSessionParameters,
+    const VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR * pUpdateInfo,
+    Dispatch const &                                                  d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkUpdateVideoSessionParametersKHR(
+      m_device,
+      static_cast<VkVideoSessionParametersKHR>( videoSessionParameters ),
+      reinterpret_cast<const VkVideoSessionParametersUpdateInfoKHR *>( pUpdateInfo ) ) );
+  }
+
+#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
+    Device::updateVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters,
+                                             const VideoSessionParametersUpdateInfoKHR &     updateInfo,
+                                             Dispatch const &                                d ) const
+  {
+    Result result = static_cast<Result>( d.vkUpdateVideoSessionParametersKHR(
+      m_device,
+      static_cast<VkVideoSessionParametersKHR>( videoSessionParameters ),
+      reinterpret_cast<const VkVideoSessionParametersUpdateInfoKHR *>( &updateInfo ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::updateVideoSessionParametersKHR" );
+  }
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    Device::destroyVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR   videoSessionParameters,
+                                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                              Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyVideoSessionParametersKHR( m_device,
+                                          static_cast<VkVideoSessionParametersKHR>( videoSessionParameters ),
+                                          reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    Device::destroyVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters,
+                                              Optional<const AllocationCallbacks>             allocator,
+                                              Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyVideoSessionParametersKHR(
+      m_device,
+      static_cast<VkVideoSessionParametersKHR>( videoSessionParameters ),
+      reinterpret_cast<const VkAllocationCallbacks *>(
+        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR   videoSessionParameters,
+                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyVideoSessionParametersKHR( m_device,
+                                          static_cast<VkVideoSessionParametersKHR>( videoSessionParameters ),
+                                          reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters,
+                                          Optional<const AllocationCallbacks>             allocator,
+                                          Dispatch const &                                d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyVideoSessionParametersKHR(
+      m_device,
+      static_cast<VkVideoSessionParametersKHR>( videoSessionParameters ),
+      reinterpret_cast<const VkAllocationCallbacks *>(
+        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    CommandBuffer::beginVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR * pBeginInfo,
+                                        Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdBeginVideoCodingKHR( m_commandBuffer, reinterpret_cast<const VkVideoBeginCodingInfoKHR *>( pBeginInfo ) );
+  }
+
+#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::beginVideoCodingKHR( const VideoBeginCodingInfoKHR & beginInfo,
+                                                             Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdBeginVideoCodingKHR( m_commandBuffer, reinterpret_cast<const VkVideoBeginCodingInfoKHR *>( &beginInfo ) );
+  }
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    CommandBuffer::endVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR * pEndCodingInfo,
+                                      Dispatch const &                                    d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdEndVideoCodingKHR( m_commandBuffer, reinterpret_cast<const VkVideoEndCodingInfoKHR *>( pEndCodingInfo ) );
+  }
+
+#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::endVideoCodingKHR( const VideoEndCodingInfoKHR & endCodingInfo,
+                                                           Dispatch const &              d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdEndVideoCodingKHR( m_commandBuffer, reinterpret_cast<const VkVideoEndCodingInfoKHR *>( &endCodingInfo ) );
+  }
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    CommandBuffer::controlVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR * pCodingControlInfo,
+                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdControlVideoCodingKHR( m_commandBuffer,
+                                  reinterpret_cast<const VkVideoCodingControlInfoKHR *>( pCodingControlInfo ) );
+  }
+
+#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::controlVideoCodingKHR( const VideoCodingControlInfoKHR & codingControlInfo,
+                                                               Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdControlVideoCodingKHR( m_commandBuffer,
+                                  reinterpret_cast<const VkVideoCodingControlInfoKHR *>( &codingControlInfo ) );
+  }
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VK_ENABLE_BETA_EXTENSIONS*/
+
+#if defined( VK_ENABLE_BETA_EXTENSIONS )
+  //=== VK_KHR_video_decode_queue ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::decodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR * pFrameInfo,
+                                                        Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdDecodeVideoKHR( m_commandBuffer, reinterpret_cast<const VkVideoDecodeInfoKHR *>( pFrameInfo ) );
+  }
+
+#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::decodeVideoKHR( const VideoDecodeInfoKHR & frameInfo,
+                                                        Dispatch const &           d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdDecodeVideoKHR( m_commandBuffer, reinterpret_cast<const VkVideoDecodeInfoKHR *>( &frameInfo ) );
+  }
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VK_ENABLE_BETA_EXTENSIONS*/
+
+  //=== VK_EXT_transform_feedback ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    CommandBuffer::bindTransformFeedbackBuffersEXT( uint32_t                                 firstBinding,
+                                                    uint32_t                                 bindingCount,
+                                                    const VULKAN_HPP_NAMESPACE::Buffer *     pBuffers,
+                                                    const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets,
+                                                    const VULKAN_HPP_NAMESPACE::DeviceSize * pSizes,
+                                                    Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdBindTransformFeedbackBuffersEXT( m_commandBuffer,
+                                            firstBinding,
+                                            bindingCount,
+                                            reinterpret_cast<const VkBuffer *>( pBuffers ),
+                                            reinterpret_cast<const VkDeviceSize *>( pOffsets ),
+                                            reinterpret_cast<const VkDeviceSize *>( pSizes ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    CommandBuffer::bindTransformFeedbackBuffersEXT( uint32_t                                               firstBinding,
+                                                    ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers,
+                                                    ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,
+                                                    ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes,
+                                                    Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
+  {
+#  ifdef VULKAN_HPP_NO_EXCEPTIONS
+    VULKAN_HPP_ASSERT( buffers.size() == offsets.size() );
+    VULKAN_HPP_ASSERT( sizes.empty() || buffers.size() == sizes.size() );
+#  else
+    if ( buffers.size() != offsets.size() )
+    {
+      throw LogicError( VULKAN_HPP_NAMESPACE_STRING
+                        "::CommandBuffer::bindTransformFeedbackBuffersEXT: buffers.size() != offsets.size()" );
+    }
+    if ( !sizes.empty() && buffers.size() != sizes.size() )
+    {
+      throw LogicError( VULKAN_HPP_NAMESPACE_STRING
+                        "::CommandBuffer::bindTransformFeedbackBuffersEXT: buffers.size() != sizes.size()" );
+    }
+#  endif /*VULKAN_HPP_NO_EXCEPTIONS*/
+
+    d.vkCmdBindTransformFeedbackBuffersEXT( m_commandBuffer,
+                                            firstBinding,
+                                            buffers.size(),
+                                            reinterpret_cast<const VkBuffer *>( buffers.data() ),
+                                            reinterpret_cast<const VkDeviceSize *>( offsets.data() ),
+                                            reinterpret_cast<const VkDeviceSize *>( sizes.data() ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    CommandBuffer::beginTransformFeedbackEXT( uint32_t                                 firstCounterBuffer,
+                                              uint32_t                                 counterBufferCount,
+                                              const VULKAN_HPP_NAMESPACE::Buffer *     pCounterBuffers,
+                                              const VULKAN_HPP_NAMESPACE::DeviceSize * pCounterBufferOffsets,
+                                              Dispatch const &                         d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdBeginTransformFeedbackEXT( m_commandBuffer,
+                                      firstCounterBuffer,
+                                      counterBufferCount,
+                                      reinterpret_cast<const VkBuffer *>( pCounterBuffers ),
+                                      reinterpret_cast<const VkDeviceSize *>( pCounterBufferOffsets ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::beginTransformFeedbackEXT(
+    uint32_t                                                   firstCounterBuffer,
+    ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &     counterBuffers,
+    ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets,
+    Dispatch const &                                           d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
+  {
+#  ifdef VULKAN_HPP_NO_EXCEPTIONS
+    VULKAN_HPP_ASSERT( counterBufferOffsets.empty() || counterBuffers.size() == counterBufferOffsets.size() );
+#  else
+    if ( !counterBufferOffsets.empty() && counterBuffers.size() != counterBufferOffsets.size() )
+    {
+      throw LogicError(
+        VULKAN_HPP_NAMESPACE_STRING
+        "::CommandBuffer::beginTransformFeedbackEXT: counterBuffers.size() != counterBufferOffsets.size()" );
+    }
+#  endif /*VULKAN_HPP_NO_EXCEPTIONS*/
+
+    d.vkCmdBeginTransformFeedbackEXT( m_commandBuffer,
+                                      firstCounterBuffer,
+                                      counterBuffers.size(),
+                                      reinterpret_cast<const VkBuffer *>( counterBuffers.data() ),
+                                      reinterpret_cast<const VkDeviceSize *>( counterBufferOffsets.data() ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    CommandBuffer::endTransformFeedbackEXT( uint32_t                                 firstCounterBuffer,
+                                            uint32_t                                 counterBufferCount,
+                                            const VULKAN_HPP_NAMESPACE::Buffer *     pCounterBuffers,
+                                            const VULKAN_HPP_NAMESPACE::DeviceSize * pCounterBufferOffsets,
+                                            Dispatch const &                         d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdEndTransformFeedbackEXT( m_commandBuffer,
+                                    firstCounterBuffer,
+                                    counterBufferCount,
+                                    reinterpret_cast<const VkBuffer *>( pCounterBuffers ),
+                                    reinterpret_cast<const VkDeviceSize *>( pCounterBufferOffsets ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::endTransformFeedbackEXT(
+    uint32_t                                                   firstCounterBuffer,
+    ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &     counterBuffers,
+    ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets,
+    Dispatch const &                                           d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
+  {
+#  ifdef VULKAN_HPP_NO_EXCEPTIONS
+    VULKAN_HPP_ASSERT( counterBufferOffsets.empty() || counterBuffers.size() == counterBufferOffsets.size() );
+#  else
+    if ( !counterBufferOffsets.empty() && counterBuffers.size() != counterBufferOffsets.size() )
+    {
+      throw LogicError(
+        VULKAN_HPP_NAMESPACE_STRING
+        "::CommandBuffer::endTransformFeedbackEXT: counterBuffers.size() != counterBufferOffsets.size()" );
+    }
+#  endif /*VULKAN_HPP_NO_EXCEPTIONS*/
+
+    d.vkCmdEndTransformFeedbackEXT( m_commandBuffer,
+                                    firstCounterBuffer,
+                                    counterBuffers.size(),
+                                    reinterpret_cast<const VkBuffer *>( counterBuffers.data() ),
+                                    reinterpret_cast<const VkDeviceSize *>( counterBufferOffsets.data() ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::beginQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool         queryPool,
+                                                              uint32_t                                query,
+                                                              VULKAN_HPP_NAMESPACE::QueryControlFlags flags,
+                                                              uint32_t                                index,
+                                                              Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdBeginQueryIndexedEXT(
+      m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query, static_cast<VkQueryControlFlags>( flags ), index );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::endQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
+                                                            uint32_t                        query,
+                                                            uint32_t                        index,
+                                                            Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdEndQueryIndexedEXT( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query, index );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::drawIndirectByteCountEXT( uint32_t                         instanceCount,
+                                                                  uint32_t                         firstInstance,
+                                                                  VULKAN_HPP_NAMESPACE::Buffer     counterBuffer,
+                                                                  VULKAN_HPP_NAMESPACE::DeviceSize counterBufferOffset,
+                                                                  uint32_t                         counterOffset,
+                                                                  uint32_t                         vertexStride,
+                                                                  Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdDrawIndirectByteCountEXT( m_commandBuffer,
+                                     instanceCount,
+                                     firstInstance,
+                                     static_cast<VkBuffer>( counterBuffer ),
+                                     static_cast<VkDeviceSize>( counterBufferOffset ),
+                                     counterOffset,
+                                     vertexStride );
+  }
+
+  //=== VK_NVX_binary_import ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::createCuModuleNVX( const VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX * pCreateInfo,
+                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
+                               VULKAN_HPP_NAMESPACE::CuModuleNVX *                 pModule,
+                               Dispatch const &                                    d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkCreateCuModuleNVX( m_device,
+                                                       reinterpret_cast<const VkCuModuleCreateInfoNVX *>( pCreateInfo ),
+                                                       reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
+                                                       reinterpret_cast<VkCuModuleNVX *>( pModule ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::CuModuleNVX>::type
+    Device::createCuModuleNVX( const CuModuleCreateInfoNVX &       createInfo,
+                               Optional<const AllocationCallbacks> allocator,
+                               Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::CuModuleNVX module;
+    Result                            result = static_cast<Result>(
+      d.vkCreateCuModuleNVX( m_device,
+                             reinterpret_cast<const VkCuModuleCreateInfoNVX *>( &createInfo ),
+                             reinterpret_cast<const VkAllocationCallbacks *>(
+                               static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                             reinterpret_cast<VkCuModuleNVX *>( &module ) ) );
+    return createResultValue( result, module, VULKAN_HPP_NAMESPACE_STRING "::Device::createCuModuleNVX" );
+  }
+
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CuModuleNVX, Dispatch>>::type
+    Device::createCuModuleNVXUnique( const CuModuleCreateInfoNVX &       createInfo,
+                                     Optional<const AllocationCallbacks> allocator,
+                                     Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::CuModuleNVX module;
+    Result                            result = static_cast<Result>(
+      d.vkCreateCuModuleNVX( m_device,
+                             reinterpret_cast<const VkCuModuleCreateInfoNVX *>( &createInfo ),
+                             reinterpret_cast<const VkAllocationCallbacks *>(
+                               static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                             reinterpret_cast<VkCuModuleNVX *>( &module ) ) );
+    ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
+    return createResultValue<VULKAN_HPP_NAMESPACE::CuModuleNVX, Dispatch>(
+      result, module, VULKAN_HPP_NAMESPACE_STRING "::Device::createCuModuleNVXUnique", deleter );
+  }
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::createCuFunctionNVX( const VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX * pCreateInfo,
+                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks *     pAllocator,
+                                 VULKAN_HPP_NAMESPACE::CuFunctionNVX *                 pFunction,
+                                 Dispatch const &                                      d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkCreateCuFunctionNVX( m_device,
+                               reinterpret_cast<const VkCuFunctionCreateInfoNVX *>( pCreateInfo ),
+                               reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
+                               reinterpret_cast<VkCuFunctionNVX *>( pFunction ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::CuFunctionNVX>::type
+    Device::createCuFunctionNVX( const CuFunctionCreateInfoNVX &     createInfo,
+                                 Optional<const AllocationCallbacks> allocator,
+                                 Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::CuFunctionNVX function;
+    Result                              result = static_cast<Result>(
+      d.vkCreateCuFunctionNVX( m_device,
+                               reinterpret_cast<const VkCuFunctionCreateInfoNVX *>( &createInfo ),
+                               reinterpret_cast<const VkAllocationCallbacks *>(
+                                 static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                               reinterpret_cast<VkCuFunctionNVX *>( &function ) ) );
+    return createResultValue( result, function, VULKAN_HPP_NAMESPACE_STRING "::Device::createCuFunctionNVX" );
+  }
+
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CuFunctionNVX, Dispatch>>::type
+    Device::createCuFunctionNVXUnique( const CuFunctionCreateInfoNVX &     createInfo,
+                                       Optional<const AllocationCallbacks> allocator,
+                                       Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::CuFunctionNVX function;
+    Result                              result = static_cast<Result>(
+      d.vkCreateCuFunctionNVX( m_device,
+                               reinterpret_cast<const VkCuFunctionCreateInfoNVX *>( &createInfo ),
+                               reinterpret_cast<const VkAllocationCallbacks *>(
+                                 static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                               reinterpret_cast<VkCuFunctionNVX *>( &function ) ) );
+    ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
+    return createResultValue<VULKAN_HPP_NAMESPACE::CuFunctionNVX, Dispatch>(
+      result, function, VULKAN_HPP_NAMESPACE_STRING "::Device::createCuFunctionNVXUnique", deleter );
+  }
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyCuModuleNVX( VULKAN_HPP_NAMESPACE::CuModuleNVX                 module,
+                                                     const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                                     Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyCuModuleNVX(
+      m_device, static_cast<VkCuModuleNVX>( module ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyCuModuleNVX( VULKAN_HPP_NAMESPACE::CuModuleNVX   module,
+                                                     Optional<const AllocationCallbacks> allocator,
+                                                     Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyCuModuleNVX( m_device,
+                            static_cast<VkCuModuleNVX>( module ),
+                            reinterpret_cast<const VkAllocationCallbacks *>(
+                              static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::CuModuleNVX                 module,
+                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyCuModuleNVX(
+      m_device, static_cast<VkCuModuleNVX>( module ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::CuModuleNVX   module,
+                                          Optional<const AllocationCallbacks> allocator,
+                                          Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyCuModuleNVX( m_device,
+                            static_cast<VkCuModuleNVX>( module ),
+                            reinterpret_cast<const VkAllocationCallbacks *>(
+                              static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyCuFunctionNVX( VULKAN_HPP_NAMESPACE::CuFunctionNVX               function,
+                                                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                                       Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyCuFunctionNVX( m_device,
+                              static_cast<VkCuFunctionNVX>( function ),
+                              reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyCuFunctionNVX( VULKAN_HPP_NAMESPACE::CuFunctionNVX function,
+                                                       Optional<const AllocationCallbacks> allocator,
+                                                       Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyCuFunctionNVX( m_device,
+                              static_cast<VkCuFunctionNVX>( function ),
+                              reinterpret_cast<const VkAllocationCallbacks *>(
+                                static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::CuFunctionNVX               function,
+                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyCuFunctionNVX( m_device,
+                              static_cast<VkCuFunctionNVX>( function ),
+                              reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::CuFunctionNVX function,
+                                          Optional<const AllocationCallbacks> allocator,
+                                          Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyCuFunctionNVX( m_device,
+                              static_cast<VkCuFunctionNVX>( function ),
+                              reinterpret_cast<const VkAllocationCallbacks *>(
+                                static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::cuLaunchKernelNVX( const VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX * pLaunchInfo,
+                                                           Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdCuLaunchKernelNVX( m_commandBuffer, reinterpret_cast<const VkCuLaunchInfoNVX *>( pLaunchInfo ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::cuLaunchKernelNVX( const CuLaunchInfoNVX & launchInfo,
+                                                           Dispatch const &        d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdCuLaunchKernelNVX( m_commandBuffer, reinterpret_cast<const VkCuLaunchInfoNVX *>( &launchInfo ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  //=== VK_NVX_image_view_handle ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE uint32_t Device::getImageViewHandleNVX( const VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX * pInfo,
+                                                            Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return d.vkGetImageViewHandleNVX( m_device, reinterpret_cast<const VkImageViewHandleInfoNVX *>( pInfo ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE uint32_t Device::getImageViewHandleNVX( const ImageViewHandleInfoNVX & info,
+                                                            Dispatch const &               d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return d.vkGetImageViewHandleNVX( m_device, reinterpret_cast<const VkImageViewHandleInfoNVX *>( &info ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::getImageViewAddressNVX( VULKAN_HPP_NAMESPACE::ImageView                       imageView,
+                                    VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX * pProperties,
+                                    Dispatch const &                                      d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkGetImageViewAddressNVX( m_device,
+                                  static_cast<VkImageView>( imageView ),
+                                  reinterpret_cast<VkImageViewAddressPropertiesNVX *>( pProperties ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX>::type
+    Device::getImageViewAddressNVX( VULKAN_HPP_NAMESPACE::ImageView imageView, Dispatch const & d ) const
+  {
+    VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX properties;
+    Result                                              result = static_cast<Result>(
+      d.vkGetImageViewAddressNVX( m_device,
+                                  static_cast<VkImageView>( imageView ),
+                                  reinterpret_cast<VkImageViewAddressPropertiesNVX *>( &properties ) ) );
+    return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING "::Device::getImageViewAddressNVX" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  //=== VK_AMD_draw_indirect_count ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer     buffer,
+                                                              VULKAN_HPP_NAMESPACE::DeviceSize offset,
+                                                              VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
+                                                              VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
+                                                              uint32_t                         maxDrawCount,
+                                                              uint32_t                         stride,
+                                                              Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdDrawIndirectCountAMD( m_commandBuffer,
+                                 static_cast<VkBuffer>( buffer ),
+                                 static_cast<VkDeviceSize>( offset ),
+                                 static_cast<VkBuffer>( countBuffer ),
+                                 static_cast<VkDeviceSize>( countBufferOffset ),
+                                 maxDrawCount,
+                                 stride );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer     buffer,
+                                                                     VULKAN_HPP_NAMESPACE::DeviceSize offset,
+                                                                     VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
+                                                                     VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
+                                                                     uint32_t                         maxDrawCount,
+                                                                     uint32_t                         stride,
+                                                                     Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdDrawIndexedIndirectCountAMD( m_commandBuffer,
+                                        static_cast<VkBuffer>( buffer ),
+                                        static_cast<VkDeviceSize>( offset ),
+                                        static_cast<VkBuffer>( countBuffer ),
+                                        static_cast<VkDeviceSize>( countBufferOffset ),
+                                        maxDrawCount,
+                                        stride );
+  }
+
+  //=== VK_AMD_shader_info ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline            pipeline,
+                              VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage,
+                              VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD   infoType,
+                              size_t *                                  pInfoSize,
+                              void *                                    pInfo,
+                              Dispatch const &                          d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkGetShaderInfoAMD( m_device,
+                                                      static_cast<VkPipeline>( pipeline ),
+                                                      static_cast<VkShaderStageFlagBits>( shaderStage ),
+                                                      static_cast<VkShaderInfoTypeAMD>( infoType ),
+                                                      pInfoSize,
+                                                      pInfo ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Uint8_tAllocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
+                       Device::getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline            pipeline,
+                              VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage,
+                              VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD   infoType,
+                              Dispatch const &                          d ) const
+  {
+    std::vector<uint8_t, Uint8_tAllocator> info;
+    size_t                                 infoSize;
+    Result                                 result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetShaderInfoAMD( m_device,
+                                                          static_cast<VkPipeline>( pipeline ),
+                                                          static_cast<VkShaderStageFlagBits>( shaderStage ),
+                                                          static_cast<VkShaderInfoTypeAMD>( infoType ),
+                                                          &infoSize,
+                                                          nullptr ) );
+      if ( ( result == Result::eSuccess ) && infoSize )
+      {
+        info.resize( infoSize );
+        result = static_cast<Result>( d.vkGetShaderInfoAMD( m_device,
+                                                            static_cast<VkPipeline>( pipeline ),
+                                                            static_cast<VkShaderStageFlagBits>( shaderStage ),
+                                                            static_cast<VkShaderInfoTypeAMD>( infoType ),
+                                                            &infoSize,
+                                                            reinterpret_cast<void *>( info.data() ) ) );
+        VULKAN_HPP_ASSERT( infoSize <= info.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( infoSize < info.size() ) )
+    {
+      info.resize( infoSize );
+    }
+    return createResultValue( result, info, VULKAN_HPP_NAMESPACE_STRING "::Device::getShaderInfoAMD" );
+  }
+
+  template <typename Uint8_tAllocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, uint8_t>::value, int>::type>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
+                       Device::getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline            pipeline,
+                              VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage,
+                              VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD   infoType,
+                              Uint8_tAllocator &                        uint8_tAllocator,
+                              Dispatch const &                          d ) const
+  {
+    std::vector<uint8_t, Uint8_tAllocator> info( uint8_tAllocator );
+    size_t                                 infoSize;
+    Result                                 result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetShaderInfoAMD( m_device,
+                                                          static_cast<VkPipeline>( pipeline ),
+                                                          static_cast<VkShaderStageFlagBits>( shaderStage ),
+                                                          static_cast<VkShaderInfoTypeAMD>( infoType ),
+                                                          &infoSize,
+                                                          nullptr ) );
+      if ( ( result == Result::eSuccess ) && infoSize )
+      {
+        info.resize( infoSize );
+        result = static_cast<Result>( d.vkGetShaderInfoAMD( m_device,
+                                                            static_cast<VkPipeline>( pipeline ),
+                                                            static_cast<VkShaderStageFlagBits>( shaderStage ),
+                                                            static_cast<VkShaderInfoTypeAMD>( infoType ),
+                                                            &infoSize,
+                                                            reinterpret_cast<void *>( info.data() ) ) );
+        VULKAN_HPP_ASSERT( infoSize <= info.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( infoSize < info.size() ) )
+    {
+      info.resize( infoSize );
+    }
+    return createResultValue( result, info, VULKAN_HPP_NAMESPACE_STRING "::Device::getShaderInfoAMD" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#if defined( VK_USE_PLATFORM_GGP )
+  //=== VK_GGP_stream_descriptor_surface ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createStreamDescriptorSurfaceGGP(
+    const VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP * pCreateInfo,
+    const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                  pAllocator,
+    VULKAN_HPP_NAMESPACE::SurfaceKHR *                                 pSurface,
+    Dispatch const &                                                   d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkCreateStreamDescriptorSurfaceGGP(
+      m_instance,
+      reinterpret_cast<const VkStreamDescriptorSurfaceCreateInfoGGP *>( pCreateInfo ),
+      reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
+      reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
+  }
+
+#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
+    Instance::createStreamDescriptorSurfaceGGP( const StreamDescriptorSurfaceCreateInfoGGP & createInfo,
+                                                Optional<const AllocationCallbacks>          allocator,
+                                                Dispatch const &                             d ) const
+  {
+    VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
+    Result                           result = static_cast<Result>( d.vkCreateStreamDescriptorSurfaceGGP(
+      m_instance,
+      reinterpret_cast<const VkStreamDescriptorSurfaceCreateInfoGGP *>( &createInfo ),
+      reinterpret_cast<const VkAllocationCallbacks *>(
+        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+      reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
+    return createResultValue(
+      result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createStreamDescriptorSurfaceGGP" );
+  }
+
+#    ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
+    Instance::createStreamDescriptorSurfaceGGPUnique( const StreamDescriptorSurfaceCreateInfoGGP & createInfo,
+                                                      Optional<const AllocationCallbacks>          allocator,
+                                                      Dispatch const &                             d ) const
+  {
+    VULKAN_HPP_NAMESPACE::SurfaceKHR  surface;
+    Result                            result = static_cast<Result>( d.vkCreateStreamDescriptorSurfaceGGP(
+      m_instance,
+      reinterpret_cast<const VkStreamDescriptorSurfaceCreateInfoGGP *>( &createInfo ),
+      reinterpret_cast<const VkAllocationCallbacks *>(
+        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+      reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
+    ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d );
+    return createResultValue<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>(
+      result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createStreamDescriptorSurfaceGGPUnique", deleter );
+  }
+#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif     /*VK_USE_PLATFORM_GGP*/
+
+  //=== VK_NV_external_memory_capabilities ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getExternalImageFormatPropertiesNV(
+    VULKAN_HPP_NAMESPACE::Format                            format,
+    VULKAN_HPP_NAMESPACE::ImageType                         type,
+    VULKAN_HPP_NAMESPACE::ImageTiling                       tiling,
+    VULKAN_HPP_NAMESPACE::ImageUsageFlags                   usage,
+    VULKAN_HPP_NAMESPACE::ImageCreateFlags                  flags,
+    VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV   externalHandleType,
+    VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV * pExternalImageFormatProperties,
+    Dispatch const &                                        d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
+      m_physicalDevice,
+      static_cast<VkFormat>( format ),
+      static_cast<VkImageType>( type ),
+      static_cast<VkImageTiling>( tiling ),
+      static_cast<VkImageUsageFlags>( usage ),
+      static_cast<VkImageCreateFlags>( flags ),
+      static_cast<VkExternalMemoryHandleTypeFlagsNV>( externalHandleType ),
+      reinterpret_cast<VkExternalImageFormatPropertiesNV *>( pExternalImageFormatProperties ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV>::type
+    PhysicalDevice::getExternalImageFormatPropertiesNV(
+      VULKAN_HPP_NAMESPACE::Format                          format,
+      VULKAN_HPP_NAMESPACE::ImageType                       type,
+      VULKAN_HPP_NAMESPACE::ImageTiling                     tiling,
+      VULKAN_HPP_NAMESPACE::ImageUsageFlags                 usage,
+      VULKAN_HPP_NAMESPACE::ImageCreateFlags                flags,
+      VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV externalHandleType,
+      Dispatch const &                                      d ) const
+  {
+    VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV externalImageFormatProperties;
+    Result result = static_cast<Result>( d.vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
+      m_physicalDevice,
+      static_cast<VkFormat>( format ),
+      static_cast<VkImageType>( type ),
+      static_cast<VkImageTiling>( tiling ),
+      static_cast<VkImageUsageFlags>( usage ),
+      static_cast<VkImageCreateFlags>( flags ),
+      static_cast<VkExternalMemoryHandleTypeFlagsNV>( externalHandleType ),
+      reinterpret_cast<VkExternalImageFormatPropertiesNV *>( &externalImageFormatProperties ) ) );
+    return createResultValue( result,
+                              externalImageFormatProperties,
+                              VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getExternalImageFormatPropertiesNV" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#if defined( VK_USE_PLATFORM_WIN32_KHR )
+  //=== VK_NV_external_memory_win32 ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::getMemoryWin32HandleNV( VULKAN_HPP_NAMESPACE::DeviceMemory                    memory,
+                                    VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleType,
+                                    HANDLE *                                              pHandle,
+                                    Dispatch const &                                      d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkGetMemoryWin32HandleNV( m_device,
+                                  static_cast<VkDeviceMemory>( memory ),
+                                  static_cast<VkExternalMemoryHandleTypeFlagsNV>( handleType ),
+                                  pHandle ) );
+  }
+
+#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<HANDLE>::type
+                                          Device::getMemoryWin32HandleNV( VULKAN_HPP_NAMESPACE::DeviceMemory                    memory,
+                                    VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleType,
+                                    Dispatch const &                                      d ) const
+  {
+    HANDLE handle;
+    Result result =
+      static_cast<Result>( d.vkGetMemoryWin32HandleNV( m_device,
+                                                       static_cast<VkDeviceMemory>( memory ),
+                                                       static_cast<VkExternalMemoryHandleTypeFlagsNV>( handleType ),
+                                                       &handle ) );
+    return createResultValue( result, handle, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryWin32HandleNV" );
+  }
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VK_USE_PLATFORM_WIN32_KHR*/
+
+  //=== VK_KHR_get_physical_device_properties2 ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void PhysicalDevice::getFeatures2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 * pFeatures,
+                                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2 *>( pFeatures ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2
+                                         PhysicalDevice::getFeatures2KHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 features;
+    d.vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2 *>( &features ) );
+    return features;
+  }
+
+  template <typename X, typename Y, typename... Z, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
+                                         PhysicalDevice::getFeatures2KHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    StructureChain<X, Y, Z...>                      structureChain;
+    VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 & features =
+      structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2>();
+    d.vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2 *>( &features ) );
+    return structureChain;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    PhysicalDevice::getProperties2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 * pProperties,
+                                       Dispatch const &                                  d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkGetPhysicalDeviceProperties2KHR( m_physicalDevice,
+                                         reinterpret_cast<VkPhysicalDeviceProperties2 *>( pProperties ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2
+    PhysicalDevice::getProperties2KHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 properties;
+    d.vkGetPhysicalDeviceProperties2KHR( m_physicalDevice,
+                                         reinterpret_cast<VkPhysicalDeviceProperties2 *>( &properties ) );
+    return properties;
+  }
+
+  template <typename X, typename Y, typename... Z, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
+    PhysicalDevice::getProperties2KHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    StructureChain<X, Y, Z...>                        structureChain;
+    VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 & properties =
+      structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2>();
+    d.vkGetPhysicalDeviceProperties2KHR( m_physicalDevice,
+                                         reinterpret_cast<VkPhysicalDeviceProperties2 *>( &properties ) );
+    return structureChain;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    PhysicalDevice::getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format              format,
+                                             VULKAN_HPP_NAMESPACE::FormatProperties2 * pFormatProperties,
+                                             Dispatch const &                          d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkGetPhysicalDeviceFormatProperties2KHR(
+      m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2 *>( pFormatProperties ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::FormatProperties2
+                                         PhysicalDevice::getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format,
+                                             Dispatch const &             d ) const VULKAN_HPP_NOEXCEPT
+  {
+    VULKAN_HPP_NAMESPACE::FormatProperties2 formatProperties;
+    d.vkGetPhysicalDeviceFormatProperties2KHR(
+      m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2 *>( &formatProperties ) );
+    return formatProperties;
+  }
+
+  template <typename X, typename Y, typename... Z, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
+                                         PhysicalDevice::getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format,
+                                             Dispatch const &             d ) const VULKAN_HPP_NOEXCEPT
+  {
+    StructureChain<X, Y, Z...>                structureChain;
+    VULKAN_HPP_NAMESPACE::FormatProperties2 & formatProperties =
+      structureChain.template get<VULKAN_HPP_NAMESPACE::FormatProperties2>();
+    d.vkGetPhysicalDeviceFormatProperties2KHR(
+      m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2 *>( &formatProperties ) );
+    return structureChain;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getImageFormatProperties2KHR(
+    const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 * pImageFormatInfo,
+    VULKAN_HPP_NAMESPACE::ImageFormatProperties2 *               pImageFormatProperties,
+    Dispatch const &                                             d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2KHR(
+      m_physicalDevice,
+      reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( pImageFormatInfo ),
+      reinterpret_cast<VkImageFormatProperties2 *>( pImageFormatProperties ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>::type
+    PhysicalDevice::getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo,
+                                                  Dispatch const &                       d ) const
+  {
+    VULKAN_HPP_NAMESPACE::ImageFormatProperties2 imageFormatProperties;
+    Result result = static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2KHR(
+      m_physicalDevice,
+      reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( &imageFormatInfo ),
+      reinterpret_cast<VkImageFormatProperties2 *>( &imageFormatProperties ) ) );
+    return createResultValue(
+      result, imageFormatProperties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2KHR" );
+  }
+
+  template <typename X, typename Y, typename... Z, typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<StructureChain<X, Y, Z...>>::type
+    PhysicalDevice::getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo,
+                                                  Dispatch const &                       d ) const
+  {
+    StructureChain<X, Y, Z...>                     structureChain;
+    VULKAN_HPP_NAMESPACE::ImageFormatProperties2 & imageFormatProperties =
+      structureChain.template get<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>();
+    Result result = static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2KHR(
+      m_physicalDevice,
+      reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( &imageFormatInfo ),
+      reinterpret_cast<VkImageFormatProperties2 *>( &imageFormatProperties ) ) );
+    return createResultValue(
+      result, structureChain, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2KHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    PhysicalDevice::getQueueFamilyProperties2KHR( uint32_t * pQueueFamilyPropertyCount,
+                                                  VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 * pQueueFamilyProperties,
+                                                  Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkGetPhysicalDeviceQueueFamilyProperties2KHR(
+      m_physicalDevice,
+      pQueueFamilyPropertyCount,
+      reinterpret_cast<VkQueueFamilyProperties2 *>( pQueueFamilyProperties ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename QueueFamilyProperties2Allocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator>
+                                         PhysicalDevice::getQueueFamilyProperties2KHR( Dispatch const & d ) const
+  {
+    std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator> queueFamilyProperties;
+    uint32_t                                                             queueFamilyPropertyCount;
+    d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
+    queueFamilyProperties.resize( queueFamilyPropertyCount );
+    d.vkGetPhysicalDeviceQueueFamilyProperties2KHR(
+      m_physicalDevice,
+      &queueFamilyPropertyCount,
+      reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) );
+    VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() );
+    return queueFamilyProperties;
+  }
+
+  template <typename QueueFamilyProperties2Allocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, QueueFamilyProperties2>::value, int>::type>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator>
+    PhysicalDevice::getQueueFamilyProperties2KHR( QueueFamilyProperties2Allocator & queueFamilyProperties2Allocator,
+                                                  Dispatch const &                  d ) const
+  {
+    std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator> queueFamilyProperties(
+      queueFamilyProperties2Allocator );
+    uint32_t queueFamilyPropertyCount;
+    d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
+    queueFamilyProperties.resize( queueFamilyPropertyCount );
+    d.vkGetPhysicalDeviceQueueFamilyProperties2KHR(
+      m_physicalDevice,
+      &queueFamilyPropertyCount,
+      reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) );
+    VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() );
+    return queueFamilyProperties;
+  }
+
+  template <typename StructureChain, typename StructureChainAllocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<StructureChain, StructureChainAllocator>
+                                         PhysicalDevice::getQueueFamilyProperties2KHR( Dispatch const & d ) const
+  {
+    uint32_t queueFamilyPropertyCount;
+    d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
+    std::vector<StructureChain, StructureChainAllocator>      returnVector( queueFamilyPropertyCount );
+    std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> queueFamilyProperties( queueFamilyPropertyCount );
+    for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ )
+    {
+      queueFamilyProperties[i].pNext =
+        returnVector[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>().pNext;
+    }
+    d.vkGetPhysicalDeviceQueueFamilyProperties2KHR(
+      m_physicalDevice,
+      &queueFamilyPropertyCount,
+      reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) );
+    VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() );
+    for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ )
+    {
+      returnVector[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>() = queueFamilyProperties[i];
+    }
+    return returnVector;
+  }
+
+  template <typename StructureChain,
+            typename StructureChainAllocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, StructureChain>::value, int>::type>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<StructureChain, StructureChainAllocator>
+    PhysicalDevice::getQueueFamilyProperties2KHR( StructureChainAllocator & structureChainAllocator,
+                                                  Dispatch const &          d ) const
+  {
+    uint32_t queueFamilyPropertyCount;
+    d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
+    std::vector<StructureChain, StructureChainAllocator>      returnVector( queueFamilyPropertyCount,
+                                                                       structureChainAllocator );
+    std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> queueFamilyProperties( queueFamilyPropertyCount );
+    for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ )
+    {
+      queueFamilyProperties[i].pNext =
+        returnVector[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>().pNext;
+    }
+    d.vkGetPhysicalDeviceQueueFamilyProperties2KHR(
+      m_physicalDevice,
+      &queueFamilyPropertyCount,
+      reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) );
+    VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() );
+    for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ )
+    {
+      returnVector[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>() = queueFamilyProperties[i];
+    }
+    return returnVector;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    PhysicalDevice::getMemoryProperties2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 * pMemoryProperties,
+                                             Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkGetPhysicalDeviceMemoryProperties2KHR(
+      m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( pMemoryProperties ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2
+    PhysicalDevice::getMemoryProperties2KHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 memoryProperties;
+    d.vkGetPhysicalDeviceMemoryProperties2KHR(
+      m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( &memoryProperties ) );
+    return memoryProperties;
+  }
+
+  template <typename X, typename Y, typename... Z, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
+    PhysicalDevice::getMemoryProperties2KHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    StructureChain<X, Y, Z...>                              structureChain;
+    VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 & memoryProperties =
+      structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2>();
+    d.vkGetPhysicalDeviceMemoryProperties2KHR(
+      m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( &memoryProperties ) );
+    return structureChain;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void PhysicalDevice::getSparseImageFormatProperties2KHR(
+    const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,
+    uint32_t *                                                         pPropertyCount,
+    VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 *               pProperties,
+    Dispatch const &                                                   d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
+      m_physicalDevice,
+      reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( pFormatInfo ),
+      pPropertyCount,
+      reinterpret_cast<VkSparseImageFormatProperties2 *>( pProperties ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename SparseImageFormatProperties2Allocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD
+    VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
+    PhysicalDevice::getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
+                                                        Dispatch const &                             d ) const
+  {
+    std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> properties;
+    uint32_t                                                                         propertyCount;
+    d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
+      m_physicalDevice,
+      reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ),
+      &propertyCount,
+      nullptr );
+    properties.resize( propertyCount );
+    d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
+      m_physicalDevice,
+      reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ),
+      &propertyCount,
+      reinterpret_cast<VkSparseImageFormatProperties2 *>( properties.data() ) );
+    VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+    return properties;
+  }
+
+  template <
+    typename SparseImageFormatProperties2Allocator,
+    typename Dispatch,
+    typename B,
+    typename std::enable_if<std::is_same<typename B::value_type, SparseImageFormatProperties2>::value, int>::type>
+  VULKAN_HPP_NODISCARD
+    VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
+                      PhysicalDevice::getSparseImageFormatProperties2KHR(
+      const PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
+      SparseImageFormatProperties2Allocator &      sparseImageFormatProperties2Allocator,
+      Dispatch const &                             d ) const
+  {
+    std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> properties(
+      sparseImageFormatProperties2Allocator );
+    uint32_t propertyCount;
+    d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
+      m_physicalDevice,
+      reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ),
+      &propertyCount,
+      nullptr );
+    properties.resize( propertyCount );
+    d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
+      m_physicalDevice,
+      reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ),
+      &propertyCount,
+      reinterpret_cast<VkSparseImageFormatProperties2 *>( properties.data() ) );
+    VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+    return properties;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  //=== VK_KHR_device_group ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    Device::getGroupPeerMemoryFeaturesKHR( uint32_t                                       heapIndex,
+                                           uint32_t                                       localDeviceIndex,
+                                           uint32_t                                       remoteDeviceIndex,
+                                           VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags * pPeerMemoryFeatures,
+                                           Dispatch const &                               d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkGetDeviceGroupPeerMemoryFeaturesKHR( m_device,
+                                             heapIndex,
+                                             localDeviceIndex,
+                                             remoteDeviceIndex,
+                                             reinterpret_cast<VkPeerMemoryFeatureFlags *>( pPeerMemoryFeatures ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags
+                                         Device::getGroupPeerMemoryFeaturesKHR( uint32_t         heapIndex,
+                                           uint32_t         localDeviceIndex,
+                                           uint32_t         remoteDeviceIndex,
+                                           Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags peerMemoryFeatures;
+    d.vkGetDeviceGroupPeerMemoryFeaturesKHR( m_device,
+                                             heapIndex,
+                                             localDeviceIndex,
+                                             remoteDeviceIndex,
+                                             reinterpret_cast<VkPeerMemoryFeatureFlags *>( &peerMemoryFeatures ) );
+    return peerMemoryFeatures;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setDeviceMaskKHR( uint32_t         deviceMask,
+                                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetDeviceMaskKHR( m_commandBuffer, deviceMask );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::dispatchBaseKHR( uint32_t         baseGroupX,
+                                                         uint32_t         baseGroupY,
+                                                         uint32_t         baseGroupZ,
+                                                         uint32_t         groupCountX,
+                                                         uint32_t         groupCountY,
+                                                         uint32_t         groupCountZ,
+                                                         Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdDispatchBaseKHR(
+      m_commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ );
+  }
+
+#if defined( VK_USE_PLATFORM_VI_NN )
+  //=== VK_NN_vi_surface ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Instance::createViSurfaceNN( const VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN * pCreateInfo,
+                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
+                                 VULKAN_HPP_NAMESPACE::SurfaceKHR *                  pSurface,
+                                 Dispatch const &                                    d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkCreateViSurfaceNN( m_instance,
+                                                       reinterpret_cast<const VkViSurfaceCreateInfoNN *>( pCreateInfo ),
+                                                       reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
+                                                       reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
+  }
+
+#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
+    Instance::createViSurfaceNN( const ViSurfaceCreateInfoNN &       createInfo,
+                                 Optional<const AllocationCallbacks> allocator,
+                                 Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
+    Result                           result = static_cast<Result>(
+      d.vkCreateViSurfaceNN( m_instance,
+                             reinterpret_cast<const VkViSurfaceCreateInfoNN *>( &createInfo ),
+                             reinterpret_cast<const VkAllocationCallbacks *>(
+                               static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                             reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
+    return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createViSurfaceNN" );
+  }
+
+#    ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
+    Instance::createViSurfaceNNUnique( const ViSurfaceCreateInfoNN &       createInfo,
+                                       Optional<const AllocationCallbacks> allocator,
+                                       Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
+    Result                           result = static_cast<Result>(
+      d.vkCreateViSurfaceNN( m_instance,
+                             reinterpret_cast<const VkViSurfaceCreateInfoNN *>( &createInfo ),
+                             reinterpret_cast<const VkAllocationCallbacks *>(
+                               static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                             reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
+    ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d );
+    return createResultValue<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>(
+      result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createViSurfaceNNUnique", deleter );
+  }
+#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif     /*VK_USE_PLATFORM_VI_NN*/
+
+  //=== VK_KHR_maintenance1 ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::trimCommandPoolKHR( VULKAN_HPP_NAMESPACE::CommandPool          commandPool,
+                                                     VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags,
+                                                     Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkTrimCommandPoolKHR(
+      m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolTrimFlags>( flags ) );
+  }
+
+  //=== VK_KHR_device_group_creation ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::enumeratePhysicalDeviceGroupsKHR(
+    uint32_t *                                            pPhysicalDeviceGroupCount,
+    VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties,
+    Dispatch const &                                      d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkEnumeratePhysicalDeviceGroupsKHR(
+      m_instance,
+      pPhysicalDeviceGroupCount,
+      reinterpret_cast<VkPhysicalDeviceGroupProperties *>( pPhysicalDeviceGroupProperties ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename PhysicalDeviceGroupPropertiesAllocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
+    typename ResultValueType<std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
+    Instance::enumeratePhysicalDeviceGroupsKHR( Dispatch const & d ) const
+  {
+    std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator> physicalDeviceGroupProperties;
+    uint32_t                                                                           physicalDeviceGroupCount;
+    Result                                                                             result;
+    do
+    {
+      result =
+        static_cast<Result>( d.vkEnumeratePhysicalDeviceGroupsKHR( m_instance, &physicalDeviceGroupCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && physicalDeviceGroupCount )
+      {
+        physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
+        result = static_cast<Result>( d.vkEnumeratePhysicalDeviceGroupsKHR(
+          m_instance,
+          &physicalDeviceGroupCount,
+          reinterpret_cast<VkPhysicalDeviceGroupProperties *>( physicalDeviceGroupProperties.data() ) ) );
+        VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( physicalDeviceGroupCount < physicalDeviceGroupProperties.size() ) )
+    {
+      physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
+    }
+    return createResultValue( result,
+                              physicalDeviceGroupProperties,
+                              VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDeviceGroupsKHR" );
+  }
+
+  template <
+    typename PhysicalDeviceGroupPropertiesAllocator,
+    typename Dispatch,
+    typename B,
+    typename std::enable_if<std::is_same<typename B::value_type, PhysicalDeviceGroupProperties>::value, int>::type>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
+    typename ResultValueType<std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
+    Instance::enumeratePhysicalDeviceGroupsKHR(
+      PhysicalDeviceGroupPropertiesAllocator & physicalDeviceGroupPropertiesAllocator, Dispatch const & d ) const
+  {
+    std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator> physicalDeviceGroupProperties(
+      physicalDeviceGroupPropertiesAllocator );
+    uint32_t physicalDeviceGroupCount;
+    Result   result;
+    do
+    {
+      result =
+        static_cast<Result>( d.vkEnumeratePhysicalDeviceGroupsKHR( m_instance, &physicalDeviceGroupCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && physicalDeviceGroupCount )
+      {
+        physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
+        result = static_cast<Result>( d.vkEnumeratePhysicalDeviceGroupsKHR(
+          m_instance,
+          &physicalDeviceGroupCount,
+          reinterpret_cast<VkPhysicalDeviceGroupProperties *>( physicalDeviceGroupProperties.data() ) ) );
+        VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( physicalDeviceGroupCount < physicalDeviceGroupProperties.size() ) )
+    {
+      physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
+    }
+    return createResultValue( result,
+                              physicalDeviceGroupProperties,
+                              VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDeviceGroupsKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  //=== VK_KHR_external_memory_capabilities ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void PhysicalDevice::getExternalBufferPropertiesKHR(
+    const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo * pExternalBufferInfo,
+    VULKAN_HPP_NAMESPACE::ExternalBufferProperties *               pExternalBufferProperties,
+    Dispatch const &                                               d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkGetPhysicalDeviceExternalBufferPropertiesKHR(
+      m_physicalDevice,
+      reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo *>( pExternalBufferInfo ),
+      reinterpret_cast<VkExternalBufferProperties *>( pExternalBufferProperties ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalBufferProperties
+    PhysicalDevice::getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfo & externalBufferInfo,
+                                                    Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    VULKAN_HPP_NAMESPACE::ExternalBufferProperties externalBufferProperties;
+    d.vkGetPhysicalDeviceExternalBufferPropertiesKHR(
+      m_physicalDevice,
+      reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo *>( &externalBufferInfo ),
+      reinterpret_cast<VkExternalBufferProperties *>( &externalBufferProperties ) );
+    return externalBufferProperties;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#if defined( VK_USE_PLATFORM_WIN32_KHR )
+  //=== VK_KHR_external_memory_win32 ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::getMemoryWin32HandleKHR( const VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR * pGetWin32HandleInfo,
+                                     HANDLE *                                                  pHandle,
+                                     Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkGetMemoryWin32HandleKHR(
+      m_device, reinterpret_cast<const VkMemoryGetWin32HandleInfoKHR *>( pGetWin32HandleInfo ), pHandle ) );
+  }
+
+#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<HANDLE>::type
+    Device::getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const & d ) const
+  {
+    HANDLE handle;
+    Result result = static_cast<Result>( d.vkGetMemoryWin32HandleKHR(
+      m_device, reinterpret_cast<const VkMemoryGetWin32HandleInfoKHR *>( &getWin32HandleInfo ), &handle ) );
+    return createResultValue( result, handle, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryWin32HandleKHR" );
+  }
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryWin32HandlePropertiesKHR(
+    VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
+    HANDLE                                                 handle,
+    VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR * pMemoryWin32HandleProperties,
+    Dispatch const &                                       d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkGetMemoryWin32HandlePropertiesKHR(
+      m_device,
+      static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ),
+      handle,
+      reinterpret_cast<VkMemoryWin32HandlePropertiesKHR *>( pMemoryWin32HandleProperties ) ) );
+  }
+
+#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR>::type
+    Device::getMemoryWin32HandlePropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
+                                               HANDLE                                                 handle,
+                                               Dispatch const &                                       d ) const
+  {
+    VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR memoryWin32HandleProperties;
+    Result result = static_cast<Result>( d.vkGetMemoryWin32HandlePropertiesKHR(
+      m_device,
+      static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ),
+      handle,
+      reinterpret_cast<VkMemoryWin32HandlePropertiesKHR *>( &memoryWin32HandleProperties ) ) );
+    return createResultValue(
+      result, memoryWin32HandleProperties, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryWin32HandlePropertiesKHR" );
+  }
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VK_USE_PLATFORM_WIN32_KHR*/
+
+  //=== VK_KHR_external_memory_fd ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::getMemoryFdKHR( const VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR * pGetFdInfo,
+                            int *                                            pFd,
+                            Dispatch const &                                 d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkGetMemoryFdKHR( m_device, reinterpret_cast<const VkMemoryGetFdInfoKHR *>( pGetFdInfo ), pFd ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<int>::type
+    Device::getMemoryFdKHR( const MemoryGetFdInfoKHR & getFdInfo, Dispatch const & d ) const
+  {
+    int    fd;
+    Result result = static_cast<Result>(
+      d.vkGetMemoryFdKHR( m_device, reinterpret_cast<const VkMemoryGetFdInfoKHR *>( &getFdInfo ), &fd ) );
+    return createResultValue( result, fd, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryFdKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::getMemoryFdPropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
+                                      int                                                    fd,
+                                      VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR *          pMemoryFdProperties,
+                                      Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkGetMemoryFdPropertiesKHR( m_device,
+                                    static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ),
+                                    fd,
+                                    reinterpret_cast<VkMemoryFdPropertiesKHR *>( pMemoryFdProperties ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR>::type
+    Device::getMemoryFdPropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
+                                      int                                                    fd,
+                                      Dispatch const &                                       d ) const
+  {
+    VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR memoryFdProperties;
+    Result                                      result = static_cast<Result>(
+      d.vkGetMemoryFdPropertiesKHR( m_device,
+                                    static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ),
+                                    fd,
+                                    reinterpret_cast<VkMemoryFdPropertiesKHR *>( &memoryFdProperties ) ) );
+    return createResultValue(
+      result, memoryFdProperties, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryFdPropertiesKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  //=== VK_KHR_external_semaphore_capabilities ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void PhysicalDevice::getExternalSemaphorePropertiesKHR(
+    const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,
+    VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties *               pExternalSemaphoreProperties,
+    Dispatch const &                                                  d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
+      m_physicalDevice,
+      reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo *>( pExternalSemaphoreInfo ),
+      reinterpret_cast<VkExternalSemaphoreProperties *>( pExternalSemaphoreProperties ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties
+                                         PhysicalDevice::getExternalSemaphorePropertiesKHR(
+      const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties externalSemaphoreProperties;
+    d.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
+      m_physicalDevice,
+      reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo *>( &externalSemaphoreInfo ),
+      reinterpret_cast<VkExternalSemaphoreProperties *>( &externalSemaphoreProperties ) );
+    return externalSemaphoreProperties;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#if defined( VK_USE_PLATFORM_WIN32_KHR )
+  //=== VK_KHR_external_semaphore_win32 ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::importSemaphoreWin32HandleKHR(
+    const VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR * pImportSemaphoreWin32HandleInfo,
+    Dispatch const &                                                d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkImportSemaphoreWin32HandleKHR(
+      m_device, reinterpret_cast<const VkImportSemaphoreWin32HandleInfoKHR *>( pImportSemaphoreWin32HandleInfo ) ) );
+  }
+
+#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
+    Device::importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo,
+                                           Dispatch const &                          d ) const
+  {
+    Result result = static_cast<Result>( d.vkImportSemaphoreWin32HandleKHR(
+      m_device, reinterpret_cast<const VkImportSemaphoreWin32HandleInfoKHR *>( &importSemaphoreWin32HandleInfo ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importSemaphoreWin32HandleKHR" );
+  }
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSemaphoreWin32HandleKHR(
+    const VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR * pGetWin32HandleInfo,
+    HANDLE *                                                     pHandle,
+    Dispatch const &                                             d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkGetSemaphoreWin32HandleKHR(
+      m_device, reinterpret_cast<const VkSemaphoreGetWin32HandleInfoKHR *>( pGetWin32HandleInfo ), pHandle ) );
+  }
+
+#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<HANDLE>::type
+    Device::getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo,
+                                        Dispatch const &                       d ) const
+  {
+    HANDLE handle;
+    Result result = static_cast<Result>( d.vkGetSemaphoreWin32HandleKHR(
+      m_device, reinterpret_cast<const VkSemaphoreGetWin32HandleInfoKHR *>( &getWin32HandleInfo ), &handle ) );
+    return createResultValue( result, handle, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreWin32HandleKHR" );
+  }
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VK_USE_PLATFORM_WIN32_KHR*/
+
+  //=== VK_KHR_external_semaphore_fd ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::importSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR * pImportSemaphoreFdInfo,
+                                  Dispatch const &                                       d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkImportSemaphoreFdKHR(
+      m_device, reinterpret_cast<const VkImportSemaphoreFdInfoKHR *>( pImportSemaphoreFdInfo ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
+    Device::importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo, Dispatch const & d ) const
+  {
+    Result result = static_cast<Result>( d.vkImportSemaphoreFdKHR(
+      m_device, reinterpret_cast<const VkImportSemaphoreFdInfoKHR *>( &importSemaphoreFdInfo ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importSemaphoreFdKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::getSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR * pGetFdInfo,
+                               int *                                               pFd,
+                               Dispatch const &                                    d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkGetSemaphoreFdKHR( m_device, reinterpret_cast<const VkSemaphoreGetFdInfoKHR *>( pGetFdInfo ), pFd ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<int>::type
+    Device::getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR & getFdInfo, Dispatch const & d ) const
+  {
+    int    fd;
+    Result result = static_cast<Result>(
+      d.vkGetSemaphoreFdKHR( m_device, reinterpret_cast<const VkSemaphoreGetFdInfoKHR *>( &getFdInfo ), &fd ) );
+    return createResultValue( result, fd, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreFdKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  //=== VK_KHR_push_descriptor ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    CommandBuffer::pushDescriptorSetKHR( VULKAN_HPP_NAMESPACE::PipelineBindPoint          pipelineBindPoint,
+                                         VULKAN_HPP_NAMESPACE::PipelineLayout             layout,
+                                         uint32_t                                         set,
+                                         uint32_t                                         descriptorWriteCount,
+                                         const VULKAN_HPP_NAMESPACE::WriteDescriptorSet * pDescriptorWrites,
+                                         Dispatch const &                                 d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdPushDescriptorSetKHR( m_commandBuffer,
+                                 static_cast<VkPipelineBindPoint>( pipelineBindPoint ),
+                                 static_cast<VkPipelineLayout>( layout ),
+                                 set,
+                                 descriptorWriteCount,
+                                 reinterpret_cast<const VkWriteDescriptorSet *>( pDescriptorWrites ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetKHR(
+    VULKAN_HPP_NAMESPACE::PipelineBindPoint                            pipelineBindPoint,
+    VULKAN_HPP_NAMESPACE::PipelineLayout                               layout,
+    uint32_t                                                           set,
+    ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites,
+    Dispatch const &                                                   d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdPushDescriptorSetKHR( m_commandBuffer,
+                                 static_cast<VkPipelineBindPoint>( pipelineBindPoint ),
+                                 static_cast<VkPipelineLayout>( layout ),
+                                 set,
+                                 descriptorWrites.size(),
+                                 reinterpret_cast<const VkWriteDescriptorSet *>( descriptorWrites.data() ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplateKHR(
+    VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
+    VULKAN_HPP_NAMESPACE::PipelineLayout           layout,
+    uint32_t                                       set,
+    const void *                                   pData,
+    Dispatch const &                               d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdPushDescriptorSetWithTemplateKHR( m_commandBuffer,
+                                             static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
+                                             static_cast<VkPipelineLayout>( layout ),
+                                             set,
+                                             pData );
+  }
+
+  //=== VK_EXT_conditional_rendering ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::beginConditionalRenderingEXT(
+    const VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT * pConditionalRenderingBegin,
+    Dispatch const &                                               d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdBeginConditionalRenderingEXT(
+      m_commandBuffer, reinterpret_cast<const VkConditionalRenderingBeginInfoEXT *>( pConditionalRenderingBegin ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    CommandBuffer::beginConditionalRenderingEXT( const ConditionalRenderingBeginInfoEXT & conditionalRenderingBegin,
+                                                 Dispatch const &                         d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdBeginConditionalRenderingEXT(
+      m_commandBuffer, reinterpret_cast<const VkConditionalRenderingBeginInfoEXT *>( &conditionalRenderingBegin ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::endConditionalRenderingEXT( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdEndConditionalRenderingEXT( m_commandBuffer );
+  }
+
+  //=== VK_KHR_descriptor_update_template ===
+
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createDescriptorUpdateTemplateKHR(
     const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo * pCreateInfo,
@@ -106522,202 +112529,3444 @@ namespace VULKAN_HPP_NAMESPACE
 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::createEvent( const VULKAN_HPP_NAMESPACE::EventCreateInfo *     pCreateInfo,
-                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                         VULKAN_HPP_NAMESPACE::Event *                     pEvent,
-                         Dispatch const &                                  d ) const VULKAN_HPP_NOEXCEPT
+  VULKAN_HPP_INLINE void
+    Device::destroyDescriptorUpdateTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
+                                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                                Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
-    return static_cast<Result>( d.vkCreateEvent( m_device,
-                                                 reinterpret_cast<const VkEventCreateInfo *>( pCreateInfo ),
-                                                 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
-                                                 reinterpret_cast<VkEvent *>( pEvent ) ) );
+    d.vkDestroyDescriptorUpdateTemplateKHR( m_device,
+                                            static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
+                                            reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
 
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::Event>::type
-                                          Device::createEvent( const EventCreateInfo &             createInfo,
-                         Optional<const AllocationCallbacks> allocator,
-                         Dispatch const &                    d ) const
+  VULKAN_HPP_INLINE void
+    Device::destroyDescriptorUpdateTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
+                                                Optional<const AllocationCallbacks>            allocator,
+                                                Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
-    VULKAN_HPP_NAMESPACE::Event event;
-    Result                      result = static_cast<Result>(
-      d.vkCreateEvent( m_device,
-                       reinterpret_cast<const VkEventCreateInfo *>( &createInfo ),
-                       reinterpret_cast<const VkAllocationCallbacks *>(
-                         static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                       reinterpret_cast<VkEvent *>( &event ) ) );
-    return createResultValue( result, event, VULKAN_HPP_NAMESPACE_STRING "::Device::createEvent" );
+    d.vkDestroyDescriptorUpdateTemplateKHR(
+      m_device,
+      static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
+      reinterpret_cast<const VkAllocationCallbacks *>(
+        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
   }
-
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Event, Dispatch>>::type
-    Device::createEventUnique( const EventCreateInfo &             createInfo,
-                               Optional<const AllocationCallbacks> allocator,
-                               Dispatch const &                    d ) const
-  {
-    VULKAN_HPP_NAMESPACE::Event event;
-    Result                      result = static_cast<Result>(
-      d.vkCreateEvent( m_device,
-                       reinterpret_cast<const VkEventCreateInfo *>( &createInfo ),
-                       reinterpret_cast<const VkAllocationCallbacks *>(
-                         static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                       reinterpret_cast<VkEvent *>( &event ) ) );
-    ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<VULKAN_HPP_NAMESPACE::Event, Dispatch>(
-      result, event, VULKAN_HPP_NAMESPACE_STRING "::Device::createEventUnique", deleter );
-  }
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::createFence( const VULKAN_HPP_NAMESPACE::FenceCreateInfo *     pCreateInfo,
-                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                         VULKAN_HPP_NAMESPACE::Fence *                     pFence,
-                         Dispatch const &                                  d ) const VULKAN_HPP_NOEXCEPT
+  VULKAN_HPP_INLINE void
+    Device::updateDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorSet            descriptorSet,
+                                                VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
+                                                const void *                                   pData,
+                                                Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
-    return static_cast<Result>( d.vkCreateFence( m_device,
-                                                 reinterpret_cast<const VkFenceCreateInfo *>( pCreateInfo ),
-                                                 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
-                                                 reinterpret_cast<VkFence *>( pFence ) ) );
+    d.vkUpdateDescriptorSetWithTemplateKHR( m_device,
+                                            static_cast<VkDescriptorSet>( descriptorSet ),
+                                            static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
+                                            pData );
+  }
+
+  //=== VK_NV_clip_space_w_scaling ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    CommandBuffer::setViewportWScalingNV( uint32_t                                         firstViewport,
+                                          uint32_t                                         viewportCount,
+                                          const VULKAN_HPP_NAMESPACE::ViewportWScalingNV * pViewportWScalings,
+                                          Dispatch const &                                 d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetViewportWScalingNV( m_commandBuffer,
+                                  firstViewport,
+                                  viewportCount,
+                                  reinterpret_cast<const VkViewportWScalingNV *>( pViewportWScalings ) );
   }
 
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::Fence>::type
-                                          Device::createFence( const FenceCreateInfo &             createInfo,
-                         Optional<const AllocationCallbacks> allocator,
-                         Dispatch const &                    d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::setViewportWScalingNV(
+    uint32_t                                                           firstViewport,
+    ArrayProxy<const VULKAN_HPP_NAMESPACE::ViewportWScalingNV> const & viewportWScalings,
+    Dispatch const &                                                   d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetViewportWScalingNV( m_commandBuffer,
+                                  firstViewport,
+                                  viewportWScalings.size(),
+                                  reinterpret_cast<const VkViewportWScalingNV *>( viewportWScalings.data() ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  //=== VK_EXT_direct_mode_display ===
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE Result PhysicalDevice::releaseDisplayEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display,
+                                                              Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkReleaseDisplayEXT( m_physicalDevice, static_cast<VkDisplayKHR>( display ) ) );
+  }
+#else
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<void>::type
+    PhysicalDevice::releaseDisplayEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d ) const
+  {
+    Result result =
+      static_cast<Result>( d.vkReleaseDisplayEXT( m_physicalDevice, static_cast<VkDisplayKHR>( display ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::releaseDisplayEXT" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
+  //=== VK_EXT_acquire_xlib_display ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::acquireXlibDisplayEXT(
+    Display * dpy, VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkAcquireXlibDisplayEXT( m_physicalDevice, dpy, static_cast<VkDisplayKHR>( display ) ) );
+  }
+
+#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
+                                          PhysicalDevice::acquireXlibDisplayEXT( Display &                        dpy,
+                                           VULKAN_HPP_NAMESPACE::DisplayKHR display,
+                                           Dispatch const &                 d ) const
+  {
+    Result result =
+      static_cast<Result>( d.vkAcquireXlibDisplayEXT( m_physicalDevice, &dpy, static_cast<VkDisplayKHR>( display ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::acquireXlibDisplayEXT" );
+  }
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    PhysicalDevice::getRandROutputDisplayEXT( Display *                          dpy,
+                                              RROutput                           rrOutput,
+                                              VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplay,
+                                              Dispatch const &                   d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkGetRandROutputDisplayEXT( m_physicalDevice, dpy, rrOutput, reinterpret_cast<VkDisplayKHR *>( pDisplay ) ) );
+  }
+
+#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type
+    PhysicalDevice::getRandROutputDisplayEXT( Display & dpy, RROutput rrOutput, Dispatch const & d ) const
+  {
+    VULKAN_HPP_NAMESPACE::DisplayKHR display;
+    Result                           result = static_cast<Result>(
+      d.vkGetRandROutputDisplayEXT( m_physicalDevice, &dpy, rrOutput, reinterpret_cast<VkDisplayKHR *>( &display ) ) );
+    return createResultValue(
+      result, display, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getRandROutputDisplayEXT" );
+  }
+
+#    ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type
+    PhysicalDevice::getRandROutputDisplayEXTUnique( Display & dpy, RROutput rrOutput, Dispatch const & d ) const
+  {
+    VULKAN_HPP_NAMESPACE::DisplayKHR display;
+    Result                           result = static_cast<Result>(
+      d.vkGetRandROutputDisplayEXT( m_physicalDevice, &dpy, rrOutput, reinterpret_cast<VkDisplayKHR *>( &display ) ) );
+    ObjectRelease<PhysicalDevice, Dispatch> deleter( *this, d );
+    return createResultValue<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>(
+      result, display, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getRandROutputDisplayEXTUnique", deleter );
+  }
+#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif     /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
+
+  //=== VK_EXT_display_surface_counter ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    PhysicalDevice::getSurfaceCapabilities2EXT( VULKAN_HPP_NAMESPACE::SurfaceKHR                surface,
+                                                VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT * pSurfaceCapabilities,
+                                                Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilities2EXT(
+      m_physicalDevice,
+      static_cast<VkSurfaceKHR>( surface ),
+      reinterpret_cast<VkSurfaceCapabilities2EXT *>( pSurfaceCapabilities ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT>::type
+    PhysicalDevice::getSurfaceCapabilities2EXT( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d ) const
+  {
+    VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT surfaceCapabilities;
+    Result result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilities2EXT(
+      m_physicalDevice,
+      static_cast<VkSurfaceKHR>( surface ),
+      reinterpret_cast<VkSurfaceCapabilities2EXT *>( &surfaceCapabilities ) ) );
+    return createResultValue(
+      result, surfaceCapabilities, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilities2EXT" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  //=== VK_EXT_display_control ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::displayPowerControlEXT( VULKAN_HPP_NAMESPACE::DisplayKHR                  display,
+                                    const VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT * pDisplayPowerInfo,
+                                    Dispatch const &                                  d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkDisplayPowerControlEXT( m_device,
+                                  static_cast<VkDisplayKHR>( display ),
+                                  reinterpret_cast<const VkDisplayPowerInfoEXT *>( pDisplayPowerInfo ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::displayPowerControlEXT(
+    VULKAN_HPP_NAMESPACE::DisplayKHR display, const DisplayPowerInfoEXT & displayPowerInfo, Dispatch const & d ) const
+  {
+    Result result = static_cast<Result>(
+      d.vkDisplayPowerControlEXT( m_device,
+                                  static_cast<VkDisplayKHR>( display ),
+                                  reinterpret_cast<const VkDisplayPowerInfoEXT *>( &displayPowerInfo ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::displayPowerControlEXT" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::registerEventEXT( const VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT *  pDeviceEventInfo,
+                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                              VULKAN_HPP_NAMESPACE::Fence *                     pFence,
+                              Dispatch const &                                  d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkRegisterDeviceEventEXT( m_device,
+                                  reinterpret_cast<const VkDeviceEventInfoEXT *>( pDeviceEventInfo ),
+                                  reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
+                                  reinterpret_cast<VkFence *>( pFence ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::Fence>::type
+    Device::registerEventEXT( const DeviceEventInfoEXT &          deviceEventInfo,
+                              Optional<const AllocationCallbacks> allocator,
+                              Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::Fence fence;
     Result                      result = static_cast<Result>(
-      d.vkCreateFence( m_device,
-                       reinterpret_cast<const VkFenceCreateInfo *>( &createInfo ),
-                       reinterpret_cast<const VkAllocationCallbacks *>(
-                         static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                       reinterpret_cast<VkFence *>( &fence ) ) );
-    return createResultValue( result, fence, VULKAN_HPP_NAMESPACE_STRING "::Device::createFence" );
+      d.vkRegisterDeviceEventEXT( m_device,
+                                  reinterpret_cast<const VkDeviceEventInfoEXT *>( &deviceEventInfo ),
+                                  reinterpret_cast<const VkAllocationCallbacks *>(
+                                    static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                  reinterpret_cast<VkFence *>( &fence ) ) );
+    return createResultValue( result, fence, VULKAN_HPP_NAMESPACE_STRING "::Device::registerEventEXT" );
   }
 
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>>::type
-    Device::createFenceUnique( const FenceCreateInfo &             createInfo,
-                               Optional<const AllocationCallbacks> allocator,
-                               Dispatch const &                    d ) const
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>>::type
+    Device::registerEventEXTUnique( const DeviceEventInfoEXT &          deviceEventInfo,
+                                    Optional<const AllocationCallbacks> allocator,
+                                    Dispatch const &                    d ) const
   {
     VULKAN_HPP_NAMESPACE::Fence fence;
     Result                      result = static_cast<Result>(
-      d.vkCreateFence( m_device,
-                       reinterpret_cast<const VkFenceCreateInfo *>( &createInfo ),
-                       reinterpret_cast<const VkAllocationCallbacks *>(
-                         static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                       reinterpret_cast<VkFence *>( &fence ) ) );
+      d.vkRegisterDeviceEventEXT( m_device,
+                                  reinterpret_cast<const VkDeviceEventInfoEXT *>( &deviceEventInfo ),
+                                  reinterpret_cast<const VkAllocationCallbacks *>(
+                                    static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                  reinterpret_cast<VkFence *>( &fence ) ) );
     ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
     return createResultValue<VULKAN_HPP_NAMESPACE::Fence, Dispatch>(
-      result, fence, VULKAN_HPP_NAMESPACE_STRING "::Device::createFenceUnique", deleter );
+      result, fence, VULKAN_HPP_NAMESPACE_STRING "::Device::registerEventEXTUnique", deleter );
   }
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::createFramebuffer( const VULKAN_HPP_NAMESPACE::FramebufferCreateInfo * pCreateInfo,
-                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
-                               VULKAN_HPP_NAMESPACE::Framebuffer *                 pFramebuffer,
-                               Dispatch const &                                    d ) const VULKAN_HPP_NOEXCEPT
+    Device::registerDisplayEventEXT( VULKAN_HPP_NAMESPACE::DisplayKHR                  display,
+                                     const VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT * pDisplayEventInfo,
+                                     const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                     VULKAN_HPP_NAMESPACE::Fence *                     pFence,
+                                     Dispatch const &                                  d ) const VULKAN_HPP_NOEXCEPT
   {
-    return static_cast<Result>( d.vkCreateFramebuffer( m_device,
-                                                       reinterpret_cast<const VkFramebufferCreateInfo *>( pCreateInfo ),
-                                                       reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
-                                                       reinterpret_cast<VkFramebuffer *>( pFramebuffer ) ) );
+    return static_cast<Result>(
+      d.vkRegisterDisplayEventEXT( m_device,
+                                   static_cast<VkDisplayKHR>( display ),
+                                   reinterpret_cast<const VkDisplayEventInfoEXT *>( pDisplayEventInfo ),
+                                   reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
+                                   reinterpret_cast<VkFence *>( pFence ) ) );
   }
 
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::Framebuffer>::type
-    Device::createFramebuffer( const FramebufferCreateInfo &       createInfo,
-                               Optional<const AllocationCallbacks> allocator,
-                               Dispatch const &                    d ) const
-  {
-    VULKAN_HPP_NAMESPACE::Framebuffer framebuffer;
-    Result                            result = static_cast<Result>(
-      d.vkCreateFramebuffer( m_device,
-                             reinterpret_cast<const VkFramebufferCreateInfo *>( &createInfo ),
-                             reinterpret_cast<const VkAllocationCallbacks *>(
-                               static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                             reinterpret_cast<VkFramebuffer *>( &framebuffer ) ) );
-    return createResultValue( result, framebuffer, VULKAN_HPP_NAMESPACE_STRING "::Device::createFramebuffer" );
-  }
-
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Framebuffer, Dispatch>>::type
-    Device::createFramebufferUnique( const FramebufferCreateInfo &       createInfo,
+  VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::Fence>::type
+    Device::registerDisplayEventEXT( VULKAN_HPP_NAMESPACE::DisplayKHR    display,
+                                     const DisplayEventInfoEXT &         displayEventInfo,
                                      Optional<const AllocationCallbacks> allocator,
                                      Dispatch const &                    d ) const
   {
-    VULKAN_HPP_NAMESPACE::Framebuffer framebuffer;
-    Result                            result = static_cast<Result>(
-      d.vkCreateFramebuffer( m_device,
-                             reinterpret_cast<const VkFramebufferCreateInfo *>( &createInfo ),
-                             reinterpret_cast<const VkAllocationCallbacks *>(
-                               static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                             reinterpret_cast<VkFramebuffer *>( &framebuffer ) ) );
+    VULKAN_HPP_NAMESPACE::Fence fence;
+    Result                      result = static_cast<Result>(
+      d.vkRegisterDisplayEventEXT( m_device,
+                                   static_cast<VkDisplayKHR>( display ),
+                                   reinterpret_cast<const VkDisplayEventInfoEXT *>( &displayEventInfo ),
+                                   reinterpret_cast<const VkAllocationCallbacks *>(
+                                     static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                   reinterpret_cast<VkFence *>( &fence ) ) );
+    return createResultValue( result, fence, VULKAN_HPP_NAMESPACE_STRING "::Device::registerDisplayEventEXT" );
+  }
+
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>>::type
+    Device::registerDisplayEventEXTUnique( VULKAN_HPP_NAMESPACE::DisplayKHR    display,
+                                           const DisplayEventInfoEXT &         displayEventInfo,
+                                           Optional<const AllocationCallbacks> allocator,
+                                           Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::Fence fence;
+    Result                      result = static_cast<Result>(
+      d.vkRegisterDisplayEventEXT( m_device,
+                                   static_cast<VkDisplayKHR>( display ),
+                                   reinterpret_cast<const VkDisplayEventInfoEXT *>( &displayEventInfo ),
+                                   reinterpret_cast<const VkAllocationCallbacks *>(
+                                     static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                   reinterpret_cast<VkFence *>( &fence ) ) );
     ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<VULKAN_HPP_NAMESPACE::Framebuffer, Dispatch>(
-      result, framebuffer, VULKAN_HPP_NAMESPACE_STRING "::Device::createFramebufferUnique", deleter );
+    return createResultValue<VULKAN_HPP_NAMESPACE::Fence, Dispatch>(
+      result, fence, VULKAN_HPP_NAMESPACE_STRING "::Device::registerDisplayEventEXTUnique", deleter );
   }
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::createGraphicsPipelines( VULKAN_HPP_NAMESPACE::PipelineCache                      pipelineCache,
-                                     uint32_t                                                 createInfoCount,
-                                     const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo * pCreateInfos,
-                                     const VULKAN_HPP_NAMESPACE::AllocationCallbacks *        pAllocator,
-                                     VULKAN_HPP_NAMESPACE::Pipeline *                         pPipelines,
+    Device::getSwapchainCounterEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR              swapchain,
+                                    VULKAN_HPP_NAMESPACE::SurfaceCounterFlagBitsEXT counter,
+                                    uint64_t *                                      pCounterValue,
+                                    Dispatch const &                                d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkGetSwapchainCounterEXT( m_device,
+                                                            static_cast<VkSwapchainKHR>( swapchain ),
+                                                            static_cast<VkSurfaceCounterFlagBitsEXT>( counter ),
+                                                            pCounterValue ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<uint64_t>::type
+                                          Device::getSwapchainCounterEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR              swapchain,
+                                    VULKAN_HPP_NAMESPACE::SurfaceCounterFlagBitsEXT counter,
+                                    Dispatch const &                                d ) const
+  {
+    uint64_t counterValue;
+    Result   result =
+      static_cast<Result>( d.vkGetSwapchainCounterEXT( m_device,
+                                                       static_cast<VkSwapchainKHR>( swapchain ),
+                                                       static_cast<VkSurfaceCounterFlagBitsEXT>( counter ),
+                                                       &counterValue ) );
+    return createResultValue( result, counterValue, VULKAN_HPP_NAMESPACE_STRING "::Device::getSwapchainCounterEXT" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  //=== VK_GOOGLE_display_timing ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::getRefreshCycleDurationGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR                 swapchain,
+                                           VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE * pDisplayTimingProperties,
+                                           Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkGetRefreshCycleDurationGOOGLE(
+      m_device,
+      static_cast<VkSwapchainKHR>( swapchain ),
+      reinterpret_cast<VkRefreshCycleDurationGOOGLE *>( pDisplayTimingProperties ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE>::type
+    Device::getRefreshCycleDurationGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d ) const
+  {
+    VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE displayTimingProperties;
+    Result                                           result = static_cast<Result>( d.vkGetRefreshCycleDurationGOOGLE(
+      m_device,
+      static_cast<VkSwapchainKHR>( swapchain ),
+      reinterpret_cast<VkRefreshCycleDurationGOOGLE *>( &displayTimingProperties ) ) );
+    return createResultValue(
+      result, displayTimingProperties, VULKAN_HPP_NAMESPACE_STRING "::Device::getRefreshCycleDurationGOOGLE" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
+                                             uint32_t *                         pPresentationTimingCount,
+                                             VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE * pPresentationTimings,
+                                             Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkGetPastPresentationTimingGOOGLE(
+      m_device,
+      static_cast<VkSwapchainKHR>( swapchain ),
+      pPresentationTimingCount,
+      reinterpret_cast<VkPastPresentationTimingGOOGLE *>( pPresentationTimings ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename PastPresentationTimingGOOGLEAllocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
+    typename ResultValueType<std::vector<PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator>>::type
+    Device::getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d ) const
+  {
+    std::vector<PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator> presentationTimings;
+    uint32_t                                                                         presentationTimingCount;
+    Result                                                                           result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetPastPresentationTimingGOOGLE(
+        m_device, static_cast<VkSwapchainKHR>( swapchain ), &presentationTimingCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && presentationTimingCount )
+      {
+        presentationTimings.resize( presentationTimingCount );
+        result = static_cast<Result>( d.vkGetPastPresentationTimingGOOGLE(
+          m_device,
+          static_cast<VkSwapchainKHR>( swapchain ),
+          &presentationTimingCount,
+          reinterpret_cast<VkPastPresentationTimingGOOGLE *>( presentationTimings.data() ) ) );
+        VULKAN_HPP_ASSERT( presentationTimingCount <= presentationTimings.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( presentationTimingCount < presentationTimings.size() ) )
+    {
+      presentationTimings.resize( presentationTimingCount );
+    }
+    return createResultValue(
+      result, presentationTimings, VULKAN_HPP_NAMESPACE_STRING "::Device::getPastPresentationTimingGOOGLE" );
+  }
+
+  template <
+    typename PastPresentationTimingGOOGLEAllocator,
+    typename Dispatch,
+    typename B,
+    typename std::enable_if<std::is_same<typename B::value_type, PastPresentationTimingGOOGLE>::value, int>::type>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
+    typename ResultValueType<std::vector<PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator>>::type
+    Device::getPastPresentationTimingGOOGLE(
+      VULKAN_HPP_NAMESPACE::SwapchainKHR      swapchain,
+      PastPresentationTimingGOOGLEAllocator & pastPresentationTimingGOOGLEAllocator,
+      Dispatch const &                        d ) const
+  {
+    std::vector<PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator> presentationTimings(
+      pastPresentationTimingGOOGLEAllocator );
+    uint32_t presentationTimingCount;
+    Result   result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetPastPresentationTimingGOOGLE(
+        m_device, static_cast<VkSwapchainKHR>( swapchain ), &presentationTimingCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && presentationTimingCount )
+      {
+        presentationTimings.resize( presentationTimingCount );
+        result = static_cast<Result>( d.vkGetPastPresentationTimingGOOGLE(
+          m_device,
+          static_cast<VkSwapchainKHR>( swapchain ),
+          &presentationTimingCount,
+          reinterpret_cast<VkPastPresentationTimingGOOGLE *>( presentationTimings.data() ) ) );
+        VULKAN_HPP_ASSERT( presentationTimingCount <= presentationTimings.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( presentationTimingCount < presentationTimings.size() ) )
+    {
+      presentationTimings.resize( presentationTimingCount );
+    }
+    return createResultValue(
+      result, presentationTimings, VULKAN_HPP_NAMESPACE_STRING "::Device::getPastPresentationTimingGOOGLE" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  //=== VK_EXT_discard_rectangles ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleEXT( uint32_t firstDiscardRectangle,
+                                                                uint32_t discardRectangleCount,
+                                                                const VULKAN_HPP_NAMESPACE::Rect2D * pDiscardRectangles,
+                                                                Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetDiscardRectangleEXT( m_commandBuffer,
+                                   firstDiscardRectangle,
+                                   discardRectangleCount,
+                                   reinterpret_cast<const VkRect2D *>( pDiscardRectangles ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    CommandBuffer::setDiscardRectangleEXT( uint32_t                                               firstDiscardRectangle,
+                                           ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & discardRectangles,
+                                           Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetDiscardRectangleEXT( m_commandBuffer,
+                                   firstDiscardRectangle,
+                                   discardRectangles.size(),
+                                   reinterpret_cast<const VkRect2D *>( discardRectangles.data() ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  //=== VK_EXT_hdr_metadata ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::setHdrMetadataEXT( uint32_t                                     swapchainCount,
+                                                    const VULKAN_HPP_NAMESPACE::SwapchainKHR *   pSwapchains,
+                                                    const VULKAN_HPP_NAMESPACE::HdrMetadataEXT * pMetadata,
+                                                    Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkSetHdrMetadataEXT( m_device,
+                           swapchainCount,
+                           reinterpret_cast<const VkSwapchainKHR *>( pSwapchains ),
+                           reinterpret_cast<const VkHdrMetadataEXT *>( pMetadata ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    Device::setHdrMetadataEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainKHR> const &   swapchains,
+                               ArrayProxy<const VULKAN_HPP_NAMESPACE::HdrMetadataEXT> const & metadata,
+                               Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
+  {
+#  ifdef VULKAN_HPP_NO_EXCEPTIONS
+    VULKAN_HPP_ASSERT( swapchains.size() == metadata.size() );
+#  else
+    if ( swapchains.size() != metadata.size() )
+    {
+      throw LogicError( VULKAN_HPP_NAMESPACE_STRING
+                        "::Device::setHdrMetadataEXT: swapchains.size() != metadata.size()" );
+    }
+#  endif /*VULKAN_HPP_NO_EXCEPTIONS*/
+
+    d.vkSetHdrMetadataEXT( m_device,
+                           swapchains.size(),
+                           reinterpret_cast<const VkSwapchainKHR *>( swapchains.data() ),
+                           reinterpret_cast<const VkHdrMetadataEXT *>( metadata.data() ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  //=== VK_KHR_create_renderpass2 ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::createRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 * pCreateInfo,
+                                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
+                                  VULKAN_HPP_NAMESPACE::RenderPass *                  pRenderPass,
+                                  Dispatch const &                                    d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkCreateRenderPass2KHR( m_device,
+                                reinterpret_cast<const VkRenderPassCreateInfo2 *>( pCreateInfo ),
+                                reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
+                                reinterpret_cast<VkRenderPass *>( pRenderPass ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::RenderPass>::type
+    Device::createRenderPass2KHR( const RenderPassCreateInfo2 &       createInfo,
+                                  Optional<const AllocationCallbacks> allocator,
+                                  Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::RenderPass renderPass;
+    Result                           result = static_cast<Result>(
+      d.vkCreateRenderPass2KHR( m_device,
+                                reinterpret_cast<const VkRenderPassCreateInfo2 *>( &createInfo ),
+                                reinterpret_cast<const VkAllocationCallbacks *>(
+                                  static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                reinterpret_cast<VkRenderPass *>( &renderPass ) ) );
+    return createResultValue( result, renderPass, VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPass2KHR" );
+  }
+
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type
+    Device::createRenderPass2KHRUnique( const RenderPassCreateInfo2 &       createInfo,
+                                        Optional<const AllocationCallbacks> allocator,
+                                        Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::RenderPass renderPass;
+    Result                           result = static_cast<Result>(
+      d.vkCreateRenderPass2KHR( m_device,
+                                reinterpret_cast<const VkRenderPassCreateInfo2 *>( &createInfo ),
+                                reinterpret_cast<const VkAllocationCallbacks *>(
+                                  static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                reinterpret_cast<VkRenderPass *>( &renderPass ) ) );
+    ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
+    return createResultValue<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>(
+      result, renderPass, VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPass2KHRUnique", deleter );
+  }
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    CommandBuffer::beginRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo * pRenderPassBegin,
+                                        const VULKAN_HPP_NAMESPACE::SubpassBeginInfo *    pSubpassBeginInfo,
+                                        Dispatch const &                                  d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdBeginRenderPass2KHR( m_commandBuffer,
+                                reinterpret_cast<const VkRenderPassBeginInfo *>( pRenderPassBegin ),
+                                reinterpret_cast<const VkSubpassBeginInfo *>( pSubpassBeginInfo ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass2KHR( const RenderPassBeginInfo & renderPassBegin,
+                                                             const SubpassBeginInfo &    subpassBeginInfo,
+                                                             Dispatch const &            d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdBeginRenderPass2KHR( m_commandBuffer,
+                                reinterpret_cast<const VkRenderPassBeginInfo *>( &renderPassBegin ),
+                                reinterpret_cast<const VkSubpassBeginInfo *>( &subpassBeginInfo ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    CommandBuffer::nextSubpass2KHR( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo * pSubpassBeginInfo,
+                                    const VULKAN_HPP_NAMESPACE::SubpassEndInfo *   pSubpassEndInfo,
+                                    Dispatch const &                               d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdNextSubpass2KHR( m_commandBuffer,
+                            reinterpret_cast<const VkSubpassBeginInfo *>( pSubpassBeginInfo ),
+                            reinterpret_cast<const VkSubpassEndInfo *>( pSubpassEndInfo ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2KHR( const SubpassBeginInfo & subpassBeginInfo,
+                                                         const SubpassEndInfo &   subpassEndInfo,
+                                                         Dispatch const &         d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdNextSubpass2KHR( m_commandBuffer,
+                            reinterpret_cast<const VkSubpassBeginInfo *>( &subpassBeginInfo ),
+                            reinterpret_cast<const VkSubpassEndInfo *>( &subpassEndInfo ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2KHR( const VULKAN_HPP_NAMESPACE::SubpassEndInfo * pSubpassEndInfo,
+                                                           Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdEndRenderPass2KHR( m_commandBuffer, reinterpret_cast<const VkSubpassEndInfo *>( pSubpassEndInfo ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2KHR( const SubpassEndInfo & subpassEndInfo,
+                                                           Dispatch const &       d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdEndRenderPass2KHR( m_commandBuffer, reinterpret_cast<const VkSubpassEndInfo *>( &subpassEndInfo ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  //=== VK_KHR_shared_presentable_image ===
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSwapchainStatusKHR(
+    VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkGetSwapchainStatusKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ) ) );
+  }
+#else
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::getSwapchainStatusKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d ) const
+  {
+    Result result =
+      static_cast<Result>( d.vkGetSwapchainStatusKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ) ) );
+    return createResultValue(
+      result,
+      VULKAN_HPP_NAMESPACE_STRING "::Device::getSwapchainStatusKHR",
+      { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR } );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  //=== VK_KHR_external_fence_capabilities ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void PhysicalDevice::getExternalFencePropertiesKHR(
+    const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo * pExternalFenceInfo,
+    VULKAN_HPP_NAMESPACE::ExternalFenceProperties *               pExternalFenceProperties,
+    Dispatch const &                                              d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkGetPhysicalDeviceExternalFencePropertiesKHR(
+      m_physicalDevice,
+      reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo *>( pExternalFenceInfo ),
+      reinterpret_cast<VkExternalFenceProperties *>( pExternalFenceProperties ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalFenceProperties
+    PhysicalDevice::getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfo & externalFenceInfo,
+                                                   Dispatch const &                        d ) const VULKAN_HPP_NOEXCEPT
+  {
+    VULKAN_HPP_NAMESPACE::ExternalFenceProperties externalFenceProperties;
+    d.vkGetPhysicalDeviceExternalFencePropertiesKHR(
+      m_physicalDevice,
+      reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo *>( &externalFenceInfo ),
+      reinterpret_cast<VkExternalFenceProperties *>( &externalFenceProperties ) );
+    return externalFenceProperties;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#if defined( VK_USE_PLATFORM_WIN32_KHR )
+  //=== VK_KHR_external_fence_win32 ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::importFenceWin32HandleKHR(
+    const VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR * pImportFenceWin32HandleInfo,
+    Dispatch const &                                            d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkImportFenceWin32HandleKHR(
+      m_device, reinterpret_cast<const VkImportFenceWin32HandleInfoKHR *>( pImportFenceWin32HandleInfo ) ) );
+  }
+
+#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
+    Device::importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo,
+                                       Dispatch const &                      d ) const
+  {
+    Result result = static_cast<Result>( d.vkImportFenceWin32HandleKHR(
+      m_device, reinterpret_cast<const VkImportFenceWin32HandleInfoKHR *>( &importFenceWin32HandleInfo ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importFenceWin32HandleKHR" );
+  }
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::getFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR * pGetWin32HandleInfo,
+                                    HANDLE *                                                 pHandle,
+                                    Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkGetFenceWin32HandleKHR(
+      m_device, reinterpret_cast<const VkFenceGetWin32HandleInfoKHR *>( pGetWin32HandleInfo ), pHandle ) );
+  }
+
+#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<HANDLE>::type
+    Device::getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const & d ) const
+  {
+    HANDLE handle;
+    Result result = static_cast<Result>( d.vkGetFenceWin32HandleKHR(
+      m_device, reinterpret_cast<const VkFenceGetWin32HandleInfoKHR *>( &getWin32HandleInfo ), &handle ) );
+    return createResultValue( result, handle, VULKAN_HPP_NAMESPACE_STRING "::Device::getFenceWin32HandleKHR" );
+  }
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VK_USE_PLATFORM_WIN32_KHR*/
+
+  //=== VK_KHR_external_fence_fd ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::importFenceFdKHR( const VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR * pImportFenceFdInfo,
+                              Dispatch const &                                   d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkImportFenceFdKHR( m_device, reinterpret_cast<const VkImportFenceFdInfoKHR *>( pImportFenceFdInfo ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
+    Device::importFenceFdKHR( const ImportFenceFdInfoKHR & importFenceFdInfo, Dispatch const & d ) const
+  {
+    Result result = static_cast<Result>(
+      d.vkImportFenceFdKHR( m_device, reinterpret_cast<const VkImportFenceFdInfoKHR *>( &importFenceFdInfo ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importFenceFdKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::getFenceFdKHR( const VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR * pGetFdInfo,
+                           int *                                           pFd,
+                           Dispatch const &                                d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkGetFenceFdKHR( m_device, reinterpret_cast<const VkFenceGetFdInfoKHR *>( pGetFdInfo ), pFd ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<int>::type
+    Device::getFenceFdKHR( const FenceGetFdInfoKHR & getFdInfo, Dispatch const & d ) const
+  {
+    int    fd;
+    Result result = static_cast<Result>(
+      d.vkGetFenceFdKHR( m_device, reinterpret_cast<const VkFenceGetFdInfoKHR *>( &getFdInfo ), &fd ) );
+    return createResultValue( result, fd, VULKAN_HPP_NAMESPACE_STRING "::Device::getFenceFdKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  //=== VK_KHR_performance_query ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR(
+    uint32_t                                                 queueFamilyIndex,
+    uint32_t *                                               pCounterCount,
+    VULKAN_HPP_NAMESPACE::PerformanceCounterKHR *            pCounters,
+    VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR * pCounterDescriptions,
+    Dispatch const &                                         d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
+      m_physicalDevice,
+      queueFamilyIndex,
+      pCounterCount,
+      reinterpret_cast<VkPerformanceCounterKHR *>( pCounters ),
+      reinterpret_cast<VkPerformanceCounterDescriptionKHR *>( pCounterDescriptions ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Allocator, typename Dispatch>
+  VULKAN_HPP_DEPRECATED( "This function is deprecated. Use one of the other flavours of it." )
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
+    typename ResultValueType<std::vector<PerformanceCounterDescriptionKHR, Allocator>>::type
+    PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR(
+      uint32_t                                                        queueFamilyIndex,
+      ArrayProxy<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR> const & counters,
+      Dispatch const &                                                d ) const
+  {
+    std::vector<PerformanceCounterDescriptionKHR, Allocator> counterDescriptions;
+    uint32_t                                                 counterCount;
+    Result                                                   result;
+    do
+    {
+      result = static_cast<Result>( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
+        m_physicalDevice,
+        queueFamilyIndex,
+        counters.size(),
+        reinterpret_cast<VkPerformanceCounterKHR *>( counters.data() ),
+        nullptr ) );
+      if ( ( result == Result::eSuccess ) && counterCount )
+      {
+        counterDescriptions.resize( counterCount );
+        result = static_cast<Result>( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
+          m_physicalDevice,
+          queueFamilyIndex,
+          counters.size(),
+          reinterpret_cast<VkPerformanceCounterKHR *>( counters.data() ),
+          reinterpret_cast<VkPerformanceCounterDescriptionKHR *>( counterDescriptions.data() ) ) );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( result == Result::eSuccess )
+    {
+      VULKAN_HPP_ASSERT( counterCount <= counterDescriptions.size() );
+      counterDescriptions.resize( counterCount );
+    }
+    return createResultValue( result,
+                              counterDescriptions,
+                              VULKAN_HPP_NAMESPACE_STRING
+                              "::PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR" );
+  }
+
+  template <
+    typename Allocator,
+    typename Dispatch,
+    typename B,
+    typename std::enable_if<std::is_same<typename B::value_type, PerformanceCounterDescriptionKHR>::value, int>::type>
+  VULKAN_HPP_DEPRECATED( "This function is deprecated. Use one of the other flavours of it." )
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
+    typename ResultValueType<std::vector<PerformanceCounterDescriptionKHR, Allocator>>::type
+    PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR(
+      uint32_t                                                        queueFamilyIndex,
+      ArrayProxy<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR> const & counters,
+      Allocator const &                                               vectorAllocator,
+      Dispatch const &                                                d ) const
+  {
+    std::vector<PerformanceCounterDescriptionKHR, Allocator> counterDescriptions( vectorAllocator );
+    uint32_t                                                 counterCount;
+    Result                                                   result;
+    do
+    {
+      result = static_cast<Result>( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
+        m_physicalDevice,
+        queueFamilyIndex,
+        counters.size(),
+        reinterpret_cast<VkPerformanceCounterKHR *>( counters.data() ),
+        nullptr ) );
+      if ( ( result == Result::eSuccess ) && counterCount )
+      {
+        counterDescriptions.resize( counterCount );
+        result = static_cast<Result>( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
+          m_physicalDevice,
+          queueFamilyIndex,
+          counters.size(),
+          reinterpret_cast<VkPerformanceCounterKHR *>( counters.data() ),
+          reinterpret_cast<VkPerformanceCounterDescriptionKHR *>( counterDescriptions.data() ) ) );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( result == Result::eSuccess )
+    {
+      VULKAN_HPP_ASSERT( counterCount <= counterDescriptions.size() );
+      counterDescriptions.resize( counterCount );
+    }
+    return createResultValue( result,
+                              counterDescriptions,
+                              VULKAN_HPP_NAMESPACE_STRING
+                              "::PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR" );
+  }
+
+  template <typename PerformanceCounterKHRAllocator,
+            typename PerformanceCounterDescriptionKHRAllocator,
+            typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<
+    std::pair<std::vector<PerformanceCounterKHR, PerformanceCounterKHRAllocator>,
+              std::vector<PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>>>::type
+    PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t         queueFamilyIndex,
+                                                                     Dispatch const & d ) const
+  {
+    std::pair<std::vector<PerformanceCounterKHR, PerformanceCounterKHRAllocator>,
+              std::vector<PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>>
+                                                                                               data;
+    std::vector<PerformanceCounterKHR, PerformanceCounterKHRAllocator> &                       counters = data.first;
+    std::vector<PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator> & counterDescriptions =
+      data.second;
+    uint32_t counterCount;
+    Result   result;
+    do
+    {
+      result = static_cast<Result>( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
+        m_physicalDevice, queueFamilyIndex, &counterCount, nullptr, nullptr ) );
+      if ( ( result == Result::eSuccess ) && counterCount )
+      {
+        counters.resize( counterCount );
+        counterDescriptions.resize( counterCount );
+        result = static_cast<Result>( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
+          m_physicalDevice,
+          queueFamilyIndex,
+          &counterCount,
+          reinterpret_cast<VkPerformanceCounterKHR *>( counters.data() ),
+          reinterpret_cast<VkPerformanceCounterDescriptionKHR *>( counterDescriptions.data() ) ) );
+        VULKAN_HPP_ASSERT( counterCount <= counters.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( counterCount < counters.size() ) )
+    {
+      counters.resize( counterCount );
+      counterDescriptions.resize( counterCount );
+    }
+    return createResultValue(
+      result, data, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR" );
+  }
+
+  template <typename PerformanceCounterKHRAllocator,
+            typename PerformanceCounterDescriptionKHRAllocator,
+            typename Dispatch,
+            typename B1,
+            typename B2,
+            typename std::enable_if<std::is_same<typename B1::value_type, PerformanceCounterKHR>::value &&
+                                      std::is_same<typename B2::value_type, PerformanceCounterDescriptionKHR>::value,
+                                    int>::type>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<
+    std::pair<std::vector<PerformanceCounterKHR, PerformanceCounterKHRAllocator>,
+              std::vector<PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>>>::type
+    PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR(
+      uint32_t                                    queueFamilyIndex,
+      PerformanceCounterKHRAllocator &            performanceCounterKHRAllocator,
+      PerformanceCounterDescriptionKHRAllocator & performanceCounterDescriptionKHRAllocator,
+      Dispatch const &                            d ) const
+  {
+    std::pair<std::vector<PerformanceCounterKHR, PerformanceCounterKHRAllocator>,
+              std::vector<PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>>
+                                                                         data( std::piecewise_construct,
+            std::forward_as_tuple( performanceCounterKHRAllocator ),
+            std::forward_as_tuple( performanceCounterDescriptionKHRAllocator ) );
+    std::vector<PerformanceCounterKHR, PerformanceCounterKHRAllocator> & counters = data.first;
+    std::vector<PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator> & counterDescriptions =
+      data.second;
+    uint32_t counterCount;
+    Result   result;
+    do
+    {
+      result = static_cast<Result>( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
+        m_physicalDevice, queueFamilyIndex, &counterCount, nullptr, nullptr ) );
+      if ( ( result == Result::eSuccess ) && counterCount )
+      {
+        counters.resize( counterCount );
+        counterDescriptions.resize( counterCount );
+        result = static_cast<Result>( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
+          m_physicalDevice,
+          queueFamilyIndex,
+          &counterCount,
+          reinterpret_cast<VkPerformanceCounterKHR *>( counters.data() ),
+          reinterpret_cast<VkPerformanceCounterDescriptionKHR *>( counterDescriptions.data() ) ) );
+        VULKAN_HPP_ASSERT( counterCount <= counters.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( counterCount < counters.size() ) )
+    {
+      counters.resize( counterCount );
+      counterDescriptions.resize( counterCount );
+    }
+    return createResultValue(
+      result, data, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyPerformanceQueryPassesKHR(
+    const VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR * pPerformanceQueryCreateInfo,
+    uint32_t *                                                      pNumPasses,
+    Dispatch const &                                                d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(
+      m_physicalDevice,
+      reinterpret_cast<const VkQueryPoolPerformanceCreateInfoKHR *>( pPerformanceQueryCreateInfo ),
+      pNumPasses );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint32_t PhysicalDevice::getQueueFamilyPerformanceQueryPassesKHR(
+    const QueryPoolPerformanceCreateInfoKHR & performanceQueryCreateInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    uint32_t numPasses;
+    d.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(
+      m_physicalDevice,
+      reinterpret_cast<const VkQueryPoolPerformanceCreateInfoKHR *>( &performanceQueryCreateInfo ),
+      &numPasses );
+    return numPasses;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::acquireProfilingLockKHR(
+    const VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR * pInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkAcquireProfilingLockKHR( m_device, reinterpret_cast<const VkAcquireProfilingLockInfoKHR *>( pInfo ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
+    Device::acquireProfilingLockKHR( const AcquireProfilingLockInfoKHR & info, Dispatch const & d ) const
+  {
+    Result result = static_cast<Result>(
+      d.vkAcquireProfilingLockKHR( m_device, reinterpret_cast<const VkAcquireProfilingLockInfoKHR *>( &info ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::acquireProfilingLockKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::releaseProfilingLockKHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkReleaseProfilingLockKHR( m_device );
+  }
+
+  //=== VK_KHR_get_surface_capabilities2 ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceCapabilities2KHR(
+    const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
+    VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR *             pSurfaceCapabilities,
+    Dispatch const &                                            d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilities2KHR(
+      m_physicalDevice,
+      reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( pSurfaceInfo ),
+      reinterpret_cast<VkSurfaceCapabilities2KHR *>( pSurfaceCapabilities ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR>::type
+    PhysicalDevice::getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
+                                                Dispatch const &                      d ) const
+  {
+    VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR surfaceCapabilities;
+    Result result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilities2KHR(
+      m_physicalDevice,
+      reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
+      reinterpret_cast<VkSurfaceCapabilities2KHR *>( &surfaceCapabilities ) ) );
+    return createResultValue(
+      result, surfaceCapabilities, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilities2KHR" );
+  }
+
+  template <typename X, typename Y, typename... Z, typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<StructureChain<X, Y, Z...>>::type
+    PhysicalDevice::getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
+                                                Dispatch const &                      d ) const
+  {
+    StructureChain<X, Y, Z...>                      structureChain;
+    VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR & surfaceCapabilities =
+      structureChain.template get<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR>();
+    Result result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilities2KHR(
+      m_physicalDevice,
+      reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
+      reinterpret_cast<VkSurfaceCapabilities2KHR *>( &surfaceCapabilities ) ) );
+    return createResultValue(
+      result, structureChain, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilities2KHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    PhysicalDevice::getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
+                                           uint32_t *                                pSurfaceFormatCount,
+                                           VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR * pSurfaceFormats,
+                                           Dispatch const &                          d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormats2KHR(
+      m_physicalDevice,
+      reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( pSurfaceInfo ),
+      pSurfaceFormatCount,
+      reinterpret_cast<VkSurfaceFormat2KHR *>( pSurfaceFormats ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename SurfaceFormat2KHRAllocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
+    typename ResultValueType<std::vector<SurfaceFormat2KHR, SurfaceFormat2KHRAllocator>>::type
+    PhysicalDevice::getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d ) const
+  {
+    std::vector<SurfaceFormat2KHR, SurfaceFormat2KHRAllocator> surfaceFormats;
+    uint32_t                                                   surfaceFormatCount;
+    Result                                                     result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormats2KHR(
+        m_physicalDevice,
+        reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
+        &surfaceFormatCount,
+        nullptr ) );
+      if ( ( result == Result::eSuccess ) && surfaceFormatCount )
+      {
+        surfaceFormats.resize( surfaceFormatCount );
+        result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormats2KHR(
+          m_physicalDevice,
+          reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
+          &surfaceFormatCount,
+          reinterpret_cast<VkSurfaceFormat2KHR *>( surfaceFormats.data() ) ) );
+        VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( surfaceFormatCount < surfaceFormats.size() ) )
+    {
+      surfaceFormats.resize( surfaceFormatCount );
+    }
+    return createResultValue(
+      result, surfaceFormats, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceFormats2KHR" );
+  }
+
+  template <typename SurfaceFormat2KHRAllocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, SurfaceFormat2KHR>::value, int>::type>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
+    typename ResultValueType<std::vector<SurfaceFormat2KHR, SurfaceFormat2KHRAllocator>>::type
+    PhysicalDevice::getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
+                                           SurfaceFormat2KHRAllocator &          surfaceFormat2KHRAllocator,
+                                           Dispatch const &                      d ) const
+  {
+    std::vector<SurfaceFormat2KHR, SurfaceFormat2KHRAllocator> surfaceFormats( surfaceFormat2KHRAllocator );
+    uint32_t                                                   surfaceFormatCount;
+    Result                                                     result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormats2KHR(
+        m_physicalDevice,
+        reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
+        &surfaceFormatCount,
+        nullptr ) );
+      if ( ( result == Result::eSuccess ) && surfaceFormatCount )
+      {
+        surfaceFormats.resize( surfaceFormatCount );
+        result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormats2KHR(
+          m_physicalDevice,
+          reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
+          &surfaceFormatCount,
+          reinterpret_cast<VkSurfaceFormat2KHR *>( surfaceFormats.data() ) ) );
+        VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( surfaceFormatCount < surfaceFormats.size() ) )
+    {
+      surfaceFormats.resize( surfaceFormatCount );
+    }
+    return createResultValue(
+      result, surfaceFormats, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceFormats2KHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  //=== VK_KHR_get_display_properties2 ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    PhysicalDevice::getDisplayProperties2KHR( uint32_t *                                    pPropertyCount,
+                                              VULKAN_HPP_NAMESPACE::DisplayProperties2KHR * pProperties,
+                                              Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkGetPhysicalDeviceDisplayProperties2KHR(
+      m_physicalDevice, pPropertyCount, reinterpret_cast<VkDisplayProperties2KHR *>( pProperties ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename DisplayProperties2KHRAllocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
+    typename ResultValueType<std::vector<DisplayProperties2KHR, DisplayProperties2KHRAllocator>>::type
+    PhysicalDevice::getDisplayProperties2KHR( Dispatch const & d ) const
+  {
+    std::vector<DisplayProperties2KHR, DisplayProperties2KHRAllocator> properties;
+    uint32_t                                                           propertyCount;
+    Result                                                             result;
+    do
+    {
+      result =
+        static_cast<Result>( d.vkGetPhysicalDeviceDisplayProperties2KHR( m_physicalDevice, &propertyCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && propertyCount )
+      {
+        properties.resize( propertyCount );
+        result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayProperties2KHR(
+          m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayProperties2KHR *>( properties.data() ) ) );
+        VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) )
+    {
+      properties.resize( propertyCount );
+    }
+    return createResultValue(
+      result, properties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayProperties2KHR" );
+  }
+
+  template <typename DisplayProperties2KHRAllocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, DisplayProperties2KHR>::value, int>::type>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
+    typename ResultValueType<std::vector<DisplayProperties2KHR, DisplayProperties2KHRAllocator>>::type
+    PhysicalDevice::getDisplayProperties2KHR( DisplayProperties2KHRAllocator & displayProperties2KHRAllocator,
+                                              Dispatch const &                 d ) const
+  {
+    std::vector<DisplayProperties2KHR, DisplayProperties2KHRAllocator> properties( displayProperties2KHRAllocator );
+    uint32_t                                                           propertyCount;
+    Result                                                             result;
+    do
+    {
+      result =
+        static_cast<Result>( d.vkGetPhysicalDeviceDisplayProperties2KHR( m_physicalDevice, &propertyCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && propertyCount )
+      {
+        properties.resize( propertyCount );
+        result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayProperties2KHR(
+          m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayProperties2KHR *>( properties.data() ) ) );
+        VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) )
+    {
+      properties.resize( propertyCount );
+    }
+    return createResultValue(
+      result, properties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayProperties2KHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    PhysicalDevice::getDisplayPlaneProperties2KHR( uint32_t *                                         pPropertyCount,
+                                                   VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR * pProperties,
+                                                   Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR(
+      m_physicalDevice, pPropertyCount, reinterpret_cast<VkDisplayPlaneProperties2KHR *>( pProperties ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename DisplayPlaneProperties2KHRAllocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
+    typename ResultValueType<std::vector<DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator>>::type
+    PhysicalDevice::getDisplayPlaneProperties2KHR( Dispatch const & d ) const
+  {
+    std::vector<DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator> properties;
+    uint32_t                                                                     propertyCount;
+    Result                                                                       result;
+    do
+    {
+      result = static_cast<Result>(
+        d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR( m_physicalDevice, &propertyCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && propertyCount )
+      {
+        properties.resize( propertyCount );
+        result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR(
+          m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPlaneProperties2KHR *>( properties.data() ) ) );
+        VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) )
+    {
+      properties.resize( propertyCount );
+    }
+    return createResultValue(
+      result, properties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneProperties2KHR" );
+  }
+
+  template <typename DisplayPlaneProperties2KHRAllocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, DisplayPlaneProperties2KHR>::value, int>::type>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
+    typename ResultValueType<std::vector<DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator>>::type
+    PhysicalDevice::getDisplayPlaneProperties2KHR(
+      DisplayPlaneProperties2KHRAllocator & displayPlaneProperties2KHRAllocator, Dispatch const & d ) const
+  {
+    std::vector<DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator> properties(
+      displayPlaneProperties2KHRAllocator );
+    uint32_t propertyCount;
+    Result   result;
+    do
+    {
+      result = static_cast<Result>(
+        d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR( m_physicalDevice, &propertyCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && propertyCount )
+      {
+        properties.resize( propertyCount );
+        result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR(
+          m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPlaneProperties2KHR *>( properties.data() ) ) );
+        VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) )
+    {
+      properties.resize( propertyCount );
+    }
+    return createResultValue(
+      result, properties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneProperties2KHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    PhysicalDevice::getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR                  display,
+                                                  uint32_t *                                        pPropertyCount,
+                                                  VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR * pProperties,
+                                                  Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkGetDisplayModeProperties2KHR( m_physicalDevice,
+                                        static_cast<VkDisplayKHR>( display ),
+                                        pPropertyCount,
+                                        reinterpret_cast<VkDisplayModeProperties2KHR *>( pProperties ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename DisplayModeProperties2KHRAllocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
+    typename ResultValueType<std::vector<DisplayModeProperties2KHR, DisplayModeProperties2KHRAllocator>>::type
+    PhysicalDevice::getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d ) const
+  {
+    std::vector<DisplayModeProperties2KHR, DisplayModeProperties2KHRAllocator> properties;
+    uint32_t                                                                   propertyCount;
+    Result                                                                     result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetDisplayModeProperties2KHR(
+        m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && propertyCount )
+      {
+        properties.resize( propertyCount );
+        result = static_cast<Result>(
+          d.vkGetDisplayModeProperties2KHR( m_physicalDevice,
+                                            static_cast<VkDisplayKHR>( display ),
+                                            &propertyCount,
+                                            reinterpret_cast<VkDisplayModeProperties2KHR *>( properties.data() ) ) );
+        VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) )
+    {
+      properties.resize( propertyCount );
+    }
+    return createResultValue(
+      result, properties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayModeProperties2KHR" );
+  }
+
+  template <typename DisplayModeProperties2KHRAllocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, DisplayModeProperties2KHR>::value, int>::type>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
+    typename ResultValueType<std::vector<DisplayModeProperties2KHR, DisplayModeProperties2KHRAllocator>>::type
+    PhysicalDevice::getDisplayModeProperties2KHR(
+      VULKAN_HPP_NAMESPACE::DisplayKHR     display,
+      DisplayModeProperties2KHRAllocator & displayModeProperties2KHRAllocator,
+      Dispatch const &                     d ) const
+  {
+    std::vector<DisplayModeProperties2KHR, DisplayModeProperties2KHRAllocator> properties(
+      displayModeProperties2KHRAllocator );
+    uint32_t propertyCount;
+    Result   result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetDisplayModeProperties2KHR(
+        m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && propertyCount )
+      {
+        properties.resize( propertyCount );
+        result = static_cast<Result>(
+          d.vkGetDisplayModeProperties2KHR( m_physicalDevice,
+                                            static_cast<VkDisplayKHR>( display ),
+                                            &propertyCount,
+                                            reinterpret_cast<VkDisplayModeProperties2KHR *>( properties.data() ) ) );
+        VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) )
+    {
+      properties.resize( propertyCount );
+    }
+    return createResultValue(
+      result, properties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayModeProperties2KHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlaneCapabilities2KHR(
+    const VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR *   pDisplayPlaneInfo,
+    VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR * pCapabilities,
+    Dispatch const &                                     d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkGetDisplayPlaneCapabilities2KHR( m_physicalDevice,
+                                           reinterpret_cast<const VkDisplayPlaneInfo2KHR *>( pDisplayPlaneInfo ),
+                                           reinterpret_cast<VkDisplayPlaneCapabilities2KHR *>( pCapabilities ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR>::type
+    PhysicalDevice::getDisplayPlaneCapabilities2KHR( const DisplayPlaneInfo2KHR & displayPlaneInfo,
+                                                     Dispatch const &             d ) const
+  {
+    VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR capabilities;
+    Result                                             result = static_cast<Result>(
+      d.vkGetDisplayPlaneCapabilities2KHR( m_physicalDevice,
+                                           reinterpret_cast<const VkDisplayPlaneInfo2KHR *>( &displayPlaneInfo ),
+                                           reinterpret_cast<VkDisplayPlaneCapabilities2KHR *>( &capabilities ) ) );
+    return createResultValue(
+      result, capabilities, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneCapabilities2KHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#if defined( VK_USE_PLATFORM_IOS_MVK )
+  //=== VK_MVK_ios_surface ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Instance::createIOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK * pCreateInfo,
+                                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks *     pAllocator,
+                                   VULKAN_HPP_NAMESPACE::SurfaceKHR *                    pSurface,
+                                   Dispatch const &                                      d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkCreateIOSSurfaceMVK( m_instance,
+                               reinterpret_cast<const VkIOSSurfaceCreateInfoMVK *>( pCreateInfo ),
+                               reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
+                               reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
+  }
+
+#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
+    Instance::createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK &     createInfo,
+                                   Optional<const AllocationCallbacks> allocator,
+                                   Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
+    Result                           result = static_cast<Result>(
+      d.vkCreateIOSSurfaceMVK( m_instance,
+                               reinterpret_cast<const VkIOSSurfaceCreateInfoMVK *>( &createInfo ),
+                               reinterpret_cast<const VkAllocationCallbacks *>(
+                                 static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                               reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
+    return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createIOSSurfaceMVK" );
+  }
+
+#    ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
+    Instance::createIOSSurfaceMVKUnique( const IOSSurfaceCreateInfoMVK &     createInfo,
+                                         Optional<const AllocationCallbacks> allocator,
+                                         Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
+    Result                           result = static_cast<Result>(
+      d.vkCreateIOSSurfaceMVK( m_instance,
+                               reinterpret_cast<const VkIOSSurfaceCreateInfoMVK *>( &createInfo ),
+                               reinterpret_cast<const VkAllocationCallbacks *>(
+                                 static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                               reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
+    ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d );
+    return createResultValue<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>(
+      result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createIOSSurfaceMVKUnique", deleter );
+  }
+#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif     /*VK_USE_PLATFORM_IOS_MVK*/
+
+#if defined( VK_USE_PLATFORM_MACOS_MVK )
+  //=== VK_MVK_macos_surface ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Instance::createMacOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK * pCreateInfo,
+                                     const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,
+                                     VULKAN_HPP_NAMESPACE::SurfaceKHR *                      pSurface,
                                      Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     return static_cast<Result>(
-      d.vkCreateGraphicsPipelines( m_device,
-                                   static_cast<VkPipelineCache>( pipelineCache ),
-                                   createInfoCount,
-                                   reinterpret_cast<const VkGraphicsPipelineCreateInfo *>( pCreateInfos ),
-                                   reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
-                                   reinterpret_cast<VkPipeline *>( pPipelines ) ) );
+      d.vkCreateMacOSSurfaceMVK( m_instance,
+                                 reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK *>( pCreateInfo ),
+                                 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
+                                 reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
+  }
+
+#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
+    Instance::createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK &   createInfo,
+                                     Optional<const AllocationCallbacks> allocator,
+                                     Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
+    Result                           result = static_cast<Result>(
+      d.vkCreateMacOSSurfaceMVK( m_instance,
+                                 reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK *>( &createInfo ),
+                                 reinterpret_cast<const VkAllocationCallbacks *>(
+                                   static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
+    return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createMacOSSurfaceMVK" );
+  }
+
+#    ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
+    Instance::createMacOSSurfaceMVKUnique( const MacOSSurfaceCreateInfoMVK &   createInfo,
+                                           Optional<const AllocationCallbacks> allocator,
+                                           Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
+    Result                           result = static_cast<Result>(
+      d.vkCreateMacOSSurfaceMVK( m_instance,
+                                 reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK *>( &createInfo ),
+                                 reinterpret_cast<const VkAllocationCallbacks *>(
+                                   static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
+    ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d );
+    return createResultValue<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>(
+      result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createMacOSSurfaceMVKUnique", deleter );
+  }
+#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif     /*VK_USE_PLATFORM_MACOS_MVK*/
+
+  //=== VK_EXT_debug_utils ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::setDebugUtilsObjectNameEXT(
+    const VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT * pNameInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkSetDebugUtilsObjectNameEXT(
+      m_device, reinterpret_cast<const VkDebugUtilsObjectNameInfoEXT *>( pNameInfo ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
+    Device::setDebugUtilsObjectNameEXT( const DebugUtilsObjectNameInfoEXT & nameInfo, Dispatch const & d ) const
+  {
+    Result result = static_cast<Result>( d.vkSetDebugUtilsObjectNameEXT(
+      m_device, reinterpret_cast<const VkDebugUtilsObjectNameInfoEXT *>( &nameInfo ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setDebugUtilsObjectNameEXT" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::setDebugUtilsObjectTagEXT(
+    const VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT * pTagInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkSetDebugUtilsObjectTagEXT( m_device, reinterpret_cast<const VkDebugUtilsObjectTagInfoEXT *>( pTagInfo ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
+    Device::setDebugUtilsObjectTagEXT( const DebugUtilsObjectTagInfoEXT & tagInfo, Dispatch const & d ) const
+  {
+    Result result = static_cast<Result>(
+      d.vkSetDebugUtilsObjectTagEXT( m_device, reinterpret_cast<const VkDebugUtilsObjectTagInfoEXT *>( &tagInfo ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setDebugUtilsObjectTagEXT" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Queue::beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo,
+                                                         Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkQueueBeginDebugUtilsLabelEXT( m_queue, reinterpret_cast<const VkDebugUtilsLabelEXT *>( pLabelInfo ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Queue::beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo,
+                                                         Dispatch const &           d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkQueueBeginDebugUtilsLabelEXT( m_queue, reinterpret_cast<const VkDebugUtilsLabelEXT *>( &labelInfo ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Queue::endDebugUtilsLabelEXT( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkQueueEndDebugUtilsLabelEXT( m_queue );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Queue::insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo,
+                                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkQueueInsertDebugUtilsLabelEXT( m_queue, reinterpret_cast<const VkDebugUtilsLabelEXT *>( pLabelInfo ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Queue::insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo,
+                                                          Dispatch const &           d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkQueueInsertDebugUtilsLabelEXT( m_queue, reinterpret_cast<const VkDebugUtilsLabelEXT *>( &labelInfo ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    CommandBuffer::beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo,
+                                            Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdBeginDebugUtilsLabelEXT( m_commandBuffer, reinterpret_cast<const VkDebugUtilsLabelEXT *>( pLabelInfo ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo,
+                                                                 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdBeginDebugUtilsLabelEXT( m_commandBuffer, reinterpret_cast<const VkDebugUtilsLabelEXT *>( &labelInfo ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::endDebugUtilsLabelEXT( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdEndDebugUtilsLabelEXT( m_commandBuffer );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    CommandBuffer::insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo,
+                                             Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdInsertDebugUtilsLabelEXT( m_commandBuffer, reinterpret_cast<const VkDebugUtilsLabelEXT *>( pLabelInfo ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo,
+                                                                  Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdInsertDebugUtilsLabelEXT( m_commandBuffer, reinterpret_cast<const VkDebugUtilsLabelEXT *>( &labelInfo ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Instance::createDebugUtilsMessengerEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT * pCreateInfo,
+                                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks *              pAllocator,
+                                            VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT *                 pMessenger,
+                                            Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkCreateDebugUtilsMessengerEXT( m_instance,
+                                        reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT *>( pCreateInfo ),
+                                        reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
+                                        reinterpret_cast<VkDebugUtilsMessengerEXT *>( pMessenger ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT>::type
+    Instance::createDebugUtilsMessengerEXT( const DebugUtilsMessengerCreateInfoEXT & createInfo,
+                                            Optional<const AllocationCallbacks>      allocator,
+                                            Dispatch const &                         d ) const
+  {
+    VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger;
+    Result                                       result = static_cast<Result>(
+      d.vkCreateDebugUtilsMessengerEXT( m_instance,
+                                        reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT *>( &createInfo ),
+                                        reinterpret_cast<const VkAllocationCallbacks *>(
+                                          static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                        reinterpret_cast<VkDebugUtilsMessengerEXT *>( &messenger ) ) );
+    return createResultValue(
+      result, messenger, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDebugUtilsMessengerEXT" );
+  }
+
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT, Dispatch>>::type
+    Instance::createDebugUtilsMessengerEXTUnique( const DebugUtilsMessengerCreateInfoEXT & createInfo,
+                                                  Optional<const AllocationCallbacks>      allocator,
+                                                  Dispatch const &                         d ) const
+  {
+    VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger;
+    Result                                       result = static_cast<Result>(
+      d.vkCreateDebugUtilsMessengerEXT( m_instance,
+                                        reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT *>( &createInfo ),
+                                        reinterpret_cast<const VkAllocationCallbacks *>(
+                                          static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                        reinterpret_cast<VkDebugUtilsMessengerEXT *>( &messenger ) ) );
+    ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d );
+    return createResultValue<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT, Dispatch>(
+      result, messenger, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDebugUtilsMessengerEXTUnique", deleter );
+  }
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    Instance::destroyDebugUtilsMessengerEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT      messenger,
+                                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                             Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyDebugUtilsMessengerEXT( m_instance,
+                                       static_cast<VkDebugUtilsMessengerEXT>( messenger ),
+                                       reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    Instance::destroyDebugUtilsMessengerEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger,
+                                             Optional<const AllocationCallbacks>          allocator,
+                                             Dispatch const &                             d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyDebugUtilsMessengerEXT(
+      m_instance,
+      static_cast<VkDebugUtilsMessengerEXT>( messenger ),
+      reinterpret_cast<const VkAllocationCallbacks *>(
+        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Instance::destroy( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT      messenger,
+                                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                            Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyDebugUtilsMessengerEXT( m_instance,
+                                       static_cast<VkDebugUtilsMessengerEXT>( messenger ),
+                                       reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Instance::destroy( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger,
+                                            Optional<const AllocationCallbacks>          allocator,
+                                            Dispatch const &                             d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyDebugUtilsMessengerEXT(
+      m_instance,
+      static_cast<VkDebugUtilsMessengerEXT>( messenger ),
+      reinterpret_cast<const VkAllocationCallbacks *>(
+        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Instance::submitDebugUtilsMessageEXT(
+    VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagBitsEXT       messageSeverity,
+    VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT              messageTypes,
+    const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT * pCallbackData,
+    Dispatch const &                                                 d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkSubmitDebugUtilsMessageEXT( m_instance,
+                                    static_cast<VkDebugUtilsMessageSeverityFlagBitsEXT>( messageSeverity ),
+                                    static_cast<VkDebugUtilsMessageTypeFlagsEXT>( messageTypes ),
+                                    reinterpret_cast<const VkDebugUtilsMessengerCallbackDataEXT *>( pCallbackData ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    Instance::submitDebugUtilsMessageEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
+                                          VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT        messageTypes,
+                                          const DebugUtilsMessengerCallbackDataEXT &                 callbackData,
+                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkSubmitDebugUtilsMessageEXT( m_instance,
+                                    static_cast<VkDebugUtilsMessageSeverityFlagBitsEXT>( messageSeverity ),
+                                    static_cast<VkDebugUtilsMessageTypeFlagsEXT>( messageTypes ),
+                                    reinterpret_cast<const VkDebugUtilsMessengerCallbackDataEXT *>( &callbackData ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#if defined( VK_USE_PLATFORM_ANDROID_KHR )
+  //=== VK_ANDROID_external_memory_android_hardware_buffer ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getAndroidHardwareBufferPropertiesANDROID(
+    const struct AHardwareBuffer *                                 buffer,
+    VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID * pProperties,
+    Dispatch const &                                               d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkGetAndroidHardwareBufferPropertiesANDROID(
+      m_device, buffer, reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID *>( pProperties ) ) );
+  }
+
+#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID>::type
+    Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const & d ) const
+  {
+    VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID properties;
+    Result result = static_cast<Result>( d.vkGetAndroidHardwareBufferPropertiesANDROID(
+      m_device, &buffer, reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID *>( &properties ) ) );
+    return createResultValue(
+      result, properties, VULKAN_HPP_NAMESPACE_STRING "::Device::getAndroidHardwareBufferPropertiesANDROID" );
+  }
+
+  template <typename X, typename Y, typename... Z, typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<StructureChain<X, Y, Z...>>::type
+    Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const & d ) const
+  {
+    StructureChain<X, Y, Z...>                                     structureChain;
+    VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID & properties =
+      structureChain.template get<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID>();
+    Result result = static_cast<Result>( d.vkGetAndroidHardwareBufferPropertiesANDROID(
+      m_device, &buffer, reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID *>( &properties ) ) );
+    return createResultValue(
+      result, structureChain, VULKAN_HPP_NAMESPACE_STRING "::Device::getAndroidHardwareBufferPropertiesANDROID" );
+  }
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryAndroidHardwareBufferANDROID(
+    const VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID * pInfo,
+    struct AHardwareBuffer **                                               pBuffer,
+    Dispatch const &                                                        d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkGetMemoryAndroidHardwareBufferANDROID(
+      m_device, reinterpret_cast<const VkMemoryGetAndroidHardwareBufferInfoANDROID *>( pInfo ), pBuffer ) );
+  }
+
+#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<struct AHardwareBuffer *>::type
+    Device::getMemoryAndroidHardwareBufferANDROID( const MemoryGetAndroidHardwareBufferInfoANDROID & info,
+                                                   Dispatch const &                                  d ) const
+  {
+    struct AHardwareBuffer * buffer;
+    Result                   result = static_cast<Result>( d.vkGetMemoryAndroidHardwareBufferANDROID(
+      m_device, reinterpret_cast<const VkMemoryGetAndroidHardwareBufferInfoANDROID *>( &info ), &buffer ) );
+    return createResultValue(
+      result, buffer, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryAndroidHardwareBufferANDROID" );
+  }
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VK_USE_PLATFORM_ANDROID_KHR*/
+
+  //=== VK_EXT_sample_locations ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    CommandBuffer::setSampleLocationsEXT( const VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT * pSampleLocationsInfo,
+                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetSampleLocationsEXT( m_commandBuffer,
+                                  reinterpret_cast<const VkSampleLocationsInfoEXT *>( pSampleLocationsInfo ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setSampleLocationsEXT( const SampleLocationsInfoEXT & sampleLocationsInfo,
+                                                               Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetSampleLocationsEXT( m_commandBuffer,
+                                  reinterpret_cast<const VkSampleLocationsInfoEXT *>( &sampleLocationsInfo ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void PhysicalDevice::getMultisamplePropertiesEXT(
+    VULKAN_HPP_NAMESPACE::SampleCountFlagBits        samples,
+    VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT * pMultisampleProperties,
+    Dispatch const &                                 d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkGetPhysicalDeviceMultisamplePropertiesEXT(
+      m_physicalDevice,
+      static_cast<VkSampleCountFlagBits>( samples ),
+      reinterpret_cast<VkMultisamplePropertiesEXT *>( pMultisampleProperties ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT
+    PhysicalDevice::getMultisamplePropertiesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,
+                                                 Dispatch const &                          d ) const VULKAN_HPP_NOEXCEPT
+  {
+    VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT multisampleProperties;
+    d.vkGetPhysicalDeviceMultisamplePropertiesEXT(
+      m_physicalDevice,
+      static_cast<VkSampleCountFlagBits>( samples ),
+      reinterpret_cast<VkMultisamplePropertiesEXT *>( &multisampleProperties ) );
+    return multisampleProperties;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  //=== VK_KHR_get_memory_requirements2 ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    Device::getImageMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 * pInfo,
+                                            VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements,
+                                            Dispatch const &                            d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkGetImageMemoryRequirements2KHR( m_device,
+                                        reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( pInfo ),
+                                        reinterpret_cast<VkMemoryRequirements2 *>( pMemoryRequirements ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2
+    Device::getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info,
+                                            Dispatch const &                     d ) const VULKAN_HPP_NOEXCEPT
+  {
+    VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements;
+    d.vkGetImageMemoryRequirements2KHR( m_device,
+                                        reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( &info ),
+                                        reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
+    return memoryRequirements;
+  }
+
+  template <typename X, typename Y, typename... Z, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
+    Device::getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info,
+                                            Dispatch const &                     d ) const VULKAN_HPP_NOEXCEPT
+  {
+    StructureChain<X, Y, Z...>                  structureChain;
+    VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements =
+      structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>();
+    d.vkGetImageMemoryRequirements2KHR( m_device,
+                                        reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( &info ),
+                                        reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
+    return structureChain;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    Device::getBufferMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 * pInfo,
+                                             VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements,
+                                             Dispatch const &                            d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkGetBufferMemoryRequirements2KHR( m_device,
+                                         reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( pInfo ),
+                                         reinterpret_cast<VkMemoryRequirements2 *>( pMemoryRequirements ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2
+    Device::getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info,
+                                             Dispatch const &                      d ) const VULKAN_HPP_NOEXCEPT
+  {
+    VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements;
+    d.vkGetBufferMemoryRequirements2KHR( m_device,
+                                         reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( &info ),
+                                         reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
+    return memoryRequirements;
+  }
+
+  template <typename X, typename Y, typename... Z, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
+    Device::getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info,
+                                             Dispatch const &                      d ) const VULKAN_HPP_NOEXCEPT
+  {
+    StructureChain<X, Y, Z...>                  structureChain;
+    VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements =
+      structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>();
+    d.vkGetBufferMemoryRequirements2KHR( m_device,
+                                         reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( &info ),
+                                         reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
+    return structureChain;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements2KHR(
+    const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 * pInfo,
+    uint32_t *                                                       pSparseMemoryRequirementCount,
+    VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 *           pSparseMemoryRequirements,
+    Dispatch const &                                                 d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkGetImageSparseMemoryRequirements2KHR(
+      m_device,
+      reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( pInfo ),
+      pSparseMemoryRequirementCount,
+      reinterpret_cast<VkSparseImageMemoryRequirements2 *>( pSparseMemoryRequirements ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename SparseImageMemoryRequirements2Allocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD
+    VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
+                      Device::getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info,
+                                                  Dispatch const &                           d ) const
+  {
+    std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> sparseMemoryRequirements;
+    uint32_t                                                                             sparseMemoryRequirementCount;
+    d.vkGetImageSparseMemoryRequirements2KHR( m_device,
+                                              reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ),
+                                              &sparseMemoryRequirementCount,
+                                              nullptr );
+    sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
+    d.vkGetImageSparseMemoryRequirements2KHR(
+      m_device,
+      reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ),
+      &sparseMemoryRequirementCount,
+      reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) );
+    VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() );
+    return sparseMemoryRequirements;
+  }
+
+  template <
+    typename SparseImageMemoryRequirements2Allocator,
+    typename Dispatch,
+    typename B,
+    typename std::enable_if<std::is_same<typename B::value_type, SparseImageMemoryRequirements2>::value, int>::type>
+  VULKAN_HPP_NODISCARD
+    VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
+                      Device::getImageSparseMemoryRequirements2KHR(
+      const ImageSparseMemoryRequirementsInfo2 & info,
+      SparseImageMemoryRequirements2Allocator &  sparseImageMemoryRequirements2Allocator,
+      Dispatch const &                           d ) const
+  {
+    std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> sparseMemoryRequirements(
+      sparseImageMemoryRequirements2Allocator );
+    uint32_t sparseMemoryRequirementCount;
+    d.vkGetImageSparseMemoryRequirements2KHR( m_device,
+                                              reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ),
+                                              &sparseMemoryRequirementCount,
+                                              nullptr );
+    sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
+    d.vkGetImageSparseMemoryRequirements2KHR(
+      m_device,
+      reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ),
+      &sparseMemoryRequirementCount,
+      reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) );
+    VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() );
+    return sparseMemoryRequirements;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  //=== VK_KHR_acceleration_structure ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createAccelerationStructureKHR(
+    const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR * pCreateInfo,
+    const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                pAllocator,
+    VULKAN_HPP_NAMESPACE::AccelerationStructureKHR *                 pAccelerationStructure,
+    Dispatch const &                                                 d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkCreateAccelerationStructureKHR( m_device,
+                                          reinterpret_cast<const VkAccelerationStructureCreateInfoKHR *>( pCreateInfo ),
+                                          reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
+                                          reinterpret_cast<VkAccelerationStructureKHR *>( pAccelerationStructure ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR>::type
+    Device::createAccelerationStructureKHR( const AccelerationStructureCreateInfoKHR & createInfo,
+                                            Optional<const AllocationCallbacks>        allocator,
+                                            Dispatch const &                           d ) const
+  {
+    VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure;
+    Result                                         result = static_cast<Result>( d.vkCreateAccelerationStructureKHR(
+      m_device,
+      reinterpret_cast<const VkAccelerationStructureCreateInfoKHR *>( &createInfo ),
+      reinterpret_cast<const VkAllocationCallbacks *>(
+        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+      reinterpret_cast<VkAccelerationStructureKHR *>( &accelerationStructure ) ) );
+    return createResultValue(
+      result, accelerationStructure, VULKAN_HPP_NAMESPACE_STRING "::Device::createAccelerationStructureKHR" );
+  }
+
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR, Dispatch>>::type
+    Device::createAccelerationStructureKHRUnique( const AccelerationStructureCreateInfoKHR & createInfo,
+                                                  Optional<const AllocationCallbacks>        allocator,
+                                                  Dispatch const &                           d ) const
+  {
+    VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure;
+    Result                                         result = static_cast<Result>( d.vkCreateAccelerationStructureKHR(
+      m_device,
+      reinterpret_cast<const VkAccelerationStructureCreateInfoKHR *>( &createInfo ),
+      reinterpret_cast<const VkAllocationCallbacks *>(
+        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+      reinterpret_cast<VkAccelerationStructureKHR *>( &accelerationStructure ) ) );
+    ObjectDestroy<Device, Dispatch>                deleter( *this, allocator, d );
+    return createResultValue<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR, Dispatch>(
+      result,
+      accelerationStructure,
+      VULKAN_HPP_NAMESPACE_STRING "::Device::createAccelerationStructureKHRUnique",
+      deleter );
+  }
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    Device::destroyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR    accelerationStructure,
+                                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                             Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyAccelerationStructureKHR( 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::destroyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure,
+                                             Optional<const AllocationCallbacks>            allocator,
+                                             Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyAccelerationStructureKHR(
+      m_device,
+      static_cast<VkAccelerationStructureKHR>( accelerationStructure ),
+      reinterpret_cast<const VkAllocationCallbacks *>(
+        static_cast<const VULKAN_HPP_NAMESPACE::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,
+                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyAccelerationStructureKHR( 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::destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure,
+                                          Optional<const AllocationCallbacks>            allocator,
+                                          Dispatch const &                               d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyAccelerationStructureKHR(
+      m_device,
+      static_cast<VkAccelerationStructureKHR>( accelerationStructure ),
+      reinterpret_cast<const VkAllocationCallbacks *>(
+        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructuresKHR(
+    uint32_t                                                                     infoCount,
+    const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR *      pInfos,
+    const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos,
+    Dispatch const &                                                             d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdBuildAccelerationStructuresKHR(
+      m_commandBuffer,
+      infoCount,
+      reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( pInfos ),
+      reinterpret_cast<const VkAccelerationStructureBuildRangeInfoKHR * const *>( ppBuildRangeInfos ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructuresKHR(
+    ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const &      infos,
+    ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos,
+    Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
+  {
+#  ifdef VULKAN_HPP_NO_EXCEPTIONS
+    VULKAN_HPP_ASSERT( infos.size() == pBuildRangeInfos.size() );
+#  else
+    if ( infos.size() != pBuildRangeInfos.size() )
+    {
+      throw LogicError( VULKAN_HPP_NAMESPACE_STRING
+                        "::CommandBuffer::buildAccelerationStructuresKHR: infos.size() != pBuildRangeInfos.size()" );
+    }
+#  endif /*VULKAN_HPP_NO_EXCEPTIONS*/
+
+    d.vkCmdBuildAccelerationStructuresKHR(
+      m_commandBuffer,
+      infos.size(),
+      reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( infos.data() ),
+      reinterpret_cast<const VkAccelerationStructureBuildRangeInfoKHR * const *>( pBuildRangeInfos.data() ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructuresIndirectKHR(
+    uint32_t                                                                infoCount,
+    const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR * pInfos,
+    const VULKAN_HPP_NAMESPACE::DeviceAddress *                             pIndirectDeviceAddresses,
+    const uint32_t *                                                        pIndirectStrides,
+    const uint32_t * const *                                                ppMaxPrimitiveCounts,
+    Dispatch const &                                                        d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdBuildAccelerationStructuresIndirectKHR(
+      m_commandBuffer,
+      infoCount,
+      reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( pInfos ),
+      reinterpret_cast<const VkDeviceAddress *>( pIndirectDeviceAddresses ),
+      pIndirectStrides,
+      ppMaxPrimitiveCounts );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructuresIndirectKHR(
+    ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos,
+    ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceAddress> const &                             indirectDeviceAddresses,
+    ArrayProxy<const uint32_t> const &                                                        indirectStrides,
+    ArrayProxy<const uint32_t * const> const &                                                pMaxPrimitiveCounts,
+    Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
+  {
+#  ifdef VULKAN_HPP_NO_EXCEPTIONS
+    VULKAN_HPP_ASSERT( infos.size() == indirectDeviceAddresses.size() );
+    VULKAN_HPP_ASSERT( infos.size() == indirectStrides.size() );
+    VULKAN_HPP_ASSERT( infos.size() == pMaxPrimitiveCounts.size() );
+#  else
+    if ( infos.size() != indirectDeviceAddresses.size() )
+    {
+      throw LogicError(
+        VULKAN_HPP_NAMESPACE_STRING
+        "::CommandBuffer::buildAccelerationStructuresIndirectKHR: infos.size() != indirectDeviceAddresses.size()" );
+    }
+    if ( infos.size() != indirectStrides.size() )
+    {
+      throw LogicError(
+        VULKAN_HPP_NAMESPACE_STRING
+        "::CommandBuffer::buildAccelerationStructuresIndirectKHR: infos.size() != indirectStrides.size()" );
+    }
+    if ( infos.size() != pMaxPrimitiveCounts.size() )
+    {
+      throw LogicError(
+        VULKAN_HPP_NAMESPACE_STRING
+        "::CommandBuffer::buildAccelerationStructuresIndirectKHR: infos.size() != pMaxPrimitiveCounts.size()" );
+    }
+#  endif /*VULKAN_HPP_NO_EXCEPTIONS*/
+
+    d.vkCmdBuildAccelerationStructuresIndirectKHR(
+      m_commandBuffer,
+      infos.size(),
+      reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( infos.data() ),
+      reinterpret_cast<const VkDeviceAddress *>( indirectDeviceAddresses.data() ),
+      indirectStrides.data(),
+      pMaxPrimitiveCounts.data() );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::buildAccelerationStructuresKHR(
+    VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                   deferredOperation,
+    uint32_t                                                                     infoCount,
+    const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR *      pInfos,
+    const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos,
+    Dispatch const &                                                             d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkBuildAccelerationStructuresKHR(
+      m_device,
+      static_cast<VkDeferredOperationKHR>( deferredOperation ),
+      infoCount,
+      reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( pInfos ),
+      reinterpret_cast<const VkAccelerationStructureBuildRangeInfoKHR * const *>( ppBuildRangeInfos ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::buildAccelerationStructuresKHR(
+    VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                                     deferredOperation,
+    ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const &      infos,
+    ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos,
+    Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
+  {
+#  ifdef VULKAN_HPP_NO_EXCEPTIONS
+    VULKAN_HPP_ASSERT( infos.size() == pBuildRangeInfos.size() );
+#  else
+    if ( infos.size() != pBuildRangeInfos.size() )
+    {
+      throw LogicError( VULKAN_HPP_NAMESPACE_STRING
+                        "::Device::buildAccelerationStructuresKHR: infos.size() != pBuildRangeInfos.size()" );
+    }
+#  endif /*VULKAN_HPP_NO_EXCEPTIONS*/
+
+    Result result = static_cast<Result>( d.vkBuildAccelerationStructuresKHR(
+      m_device,
+      static_cast<VkDeferredOperationKHR>( deferredOperation ),
+      infos.size(),
+      reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( infos.data() ),
+      reinterpret_cast<const VkAccelerationStructureBuildRangeInfoKHR * const *>( pBuildRangeInfos.data() ) ) );
+    return createResultValue( result,
+                              VULKAN_HPP_NAMESPACE_STRING "::Device::buildAccelerationStructuresKHR",
+                              { VULKAN_HPP_NAMESPACE::Result::eSuccess,
+                                VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR,
+                                VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR } );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::copyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
+                                          const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR * pInfo,
+                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkCopyAccelerationStructureKHR( m_device,
+                                        static_cast<VkDeferredOperationKHR>( deferredOperation ),
+                                        reinterpret_cast<const VkCopyAccelerationStructureInfoKHR *>( pInfo ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::copyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
+                                          const CopyAccelerationStructureInfoKHR &   info,
+                                          Dispatch const &                           d ) const
+  {
+    Result result = static_cast<Result>(
+      d.vkCopyAccelerationStructureKHR( m_device,
+                                        static_cast<VkDeferredOperationKHR>( deferredOperation ),
+                                        reinterpret_cast<const VkCopyAccelerationStructureInfoKHR *>( &info ) ) );
+    return createResultValue( result,
+                              VULKAN_HPP_NAMESPACE_STRING "::Device::copyAccelerationStructureKHR",
+                              { VULKAN_HPP_NAMESPACE::Result::eSuccess,
+                                VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR,
+                                VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR } );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyAccelerationStructureToMemoryKHR(
+    VULKAN_HPP_NAMESPACE::DeferredOperationKHR                             deferredOperation,
+    const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR * pInfo,
+    Dispatch const &                                                       d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkCopyAccelerationStructureToMemoryKHR(
+      m_device,
+      static_cast<VkDeferredOperationKHR>( deferredOperation ),
+      reinterpret_cast<const VkCopyAccelerationStructureToMemoryInfoKHR *>( pInfo ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::copyAccelerationStructureToMemoryKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR       deferredOperation,
+                                                  const CopyAccelerationStructureToMemoryInfoKHR & info,
+                                                  Dispatch const &                                 d ) const
+  {
+    Result result = static_cast<Result>( d.vkCopyAccelerationStructureToMemoryKHR(
+      m_device,
+      static_cast<VkDeferredOperationKHR>( deferredOperation ),
+      reinterpret_cast<const VkCopyAccelerationStructureToMemoryInfoKHR *>( &info ) ) );
+    return createResultValue( result,
+                              VULKAN_HPP_NAMESPACE_STRING "::Device::copyAccelerationStructureToMemoryKHR",
+                              { VULKAN_HPP_NAMESPACE::Result::eSuccess,
+                                VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR,
+                                VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR } );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyMemoryToAccelerationStructureKHR(
+    VULKAN_HPP_NAMESPACE::DeferredOperationKHR                             deferredOperation,
+    const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR * pInfo,
+    Dispatch const &                                                       d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkCopyMemoryToAccelerationStructureKHR(
+      m_device,
+      static_cast<VkDeferredOperationKHR>( deferredOperation ),
+      reinterpret_cast<const VkCopyMemoryToAccelerationStructureInfoKHR *>( pInfo ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::copyMemoryToAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR       deferredOperation,
+                                                  const CopyMemoryToAccelerationStructureInfoKHR & info,
+                                                  Dispatch const &                                 d ) const
+  {
+    Result result = static_cast<Result>( d.vkCopyMemoryToAccelerationStructureKHR(
+      m_device,
+      static_cast<VkDeferredOperationKHR>( deferredOperation ),
+      reinterpret_cast<const VkCopyMemoryToAccelerationStructureInfoKHR *>( &info ) ) );
+    return createResultValue( result,
+                              VULKAN_HPP_NAMESPACE_STRING "::Device::copyMemoryToAccelerationStructureKHR",
+                              { VULKAN_HPP_NAMESPACE::Result::eSuccess,
+                                VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR,
+                                VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR } );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::writeAccelerationStructuresPropertiesKHR(
+    uint32_t                                               accelerationStructureCount,
+    const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR * pAccelerationStructures,
+    VULKAN_HPP_NAMESPACE::QueryType                        queryType,
+    size_t                                                 dataSize,
+    void *                                                 pData,
+    size_t                                                 stride,
+    Dispatch const &                                       d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkWriteAccelerationStructuresPropertiesKHR(
+      m_device,
+      accelerationStructureCount,
+      reinterpret_cast<const VkAccelerationStructureKHR *>( pAccelerationStructures ),
+      static_cast<VkQueryType>( queryType ),
+      dataSize,
+      pData,
+      stride ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename T, typename Dispatch>
+  VULKAN_HPP_DEPRECATED( "This function is deprecated. Use one of the other flavours of it." )
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<void>::type Device::writeAccelerationStructuresPropertiesKHR(
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
+      VULKAN_HPP_NAMESPACE::QueryType                                          queryType,
+      ArrayProxy<T> const &                                                    data,
+      size_t                                                                   stride,
+      Dispatch const &                                                         d ) const
+  {
+    Result result = static_cast<Result>( d.vkWriteAccelerationStructuresPropertiesKHR(
+      m_device,
+      accelerationStructures.size(),
+      reinterpret_cast<const VkAccelerationStructureKHR *>( accelerationStructures.data() ),
+      static_cast<VkQueryType>( queryType ),
+      data.size() * sizeof( T ),
+      reinterpret_cast<void *>( data.data() ),
+      stride ) );
+    return createResultValue( result,
+                              VULKAN_HPP_NAMESPACE_STRING "::Device::writeAccelerationStructuresPropertiesKHR" );
+  }
+
+  template <typename T, typename Allocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<std::vector<T, Allocator>>::type
+                                          Device::writeAccelerationStructuresPropertiesKHR(
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
+      VULKAN_HPP_NAMESPACE::QueryType                                          queryType,
+      size_t                                                                   dataSize,
+      size_t                                                                   stride,
+      Dispatch const &                                                         d ) const
+  {
+    VULKAN_HPP_ASSERT( dataSize % sizeof( T ) == 0 );
+    std::vector<T, Allocator> data( dataSize / sizeof( T ) );
+    Result                    result = static_cast<Result>( d.vkWriteAccelerationStructuresPropertiesKHR(
+      m_device,
+      accelerationStructures.size(),
+      reinterpret_cast<const VkAccelerationStructureKHR *>( accelerationStructures.data() ),
+      static_cast<VkQueryType>( queryType ),
+      data.size() * sizeof( T ),
+      reinterpret_cast<void *>( data.data() ),
+      stride ) );
+    return createResultValue(
+      result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::writeAccelerationStructuresPropertiesKHR" );
+  }
+
+  template <typename T, typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<T>::type
+                                          Device::writeAccelerationStructuresPropertyKHR(
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
+      VULKAN_HPP_NAMESPACE::QueryType                                          queryType,
+      size_t                                                                   stride,
+      Dispatch const &                                                         d ) const
+  {
+    T      data;
+    Result result = static_cast<Result>( d.vkWriteAccelerationStructuresPropertiesKHR(
+      m_device,
+      accelerationStructures.size(),
+      reinterpret_cast<const VkAccelerationStructureKHR *>( accelerationStructures.data() ),
+      static_cast<VkQueryType>( queryType ),
+      sizeof( T ),
+      reinterpret_cast<void *>( &data ),
+      stride ) );
+    return createResultValue(
+      result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::writeAccelerationStructuresPropertyKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    CommandBuffer::copyAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR * pInfo,
+                                                 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdCopyAccelerationStructureKHR( m_commandBuffer,
+                                         reinterpret_cast<const VkCopyAccelerationStructureInfoKHR *>( pInfo ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureKHR( const CopyAccelerationStructureInfoKHR & info,
+                                                                      Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdCopyAccelerationStructureKHR( m_commandBuffer,
+                                         reinterpret_cast<const VkCopyAccelerationStructureInfoKHR *>( &info ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureToMemoryKHR(
+    const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR * pInfo,
+    Dispatch const &                                                       d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdCopyAccelerationStructureToMemoryKHR(
+      m_commandBuffer, reinterpret_cast<const VkCopyAccelerationStructureToMemoryInfoKHR *>( pInfo ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    CommandBuffer::copyAccelerationStructureToMemoryKHR( const CopyAccelerationStructureToMemoryInfoKHR & info,
+                                                         Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdCopyAccelerationStructureToMemoryKHR(
+      m_commandBuffer, reinterpret_cast<const VkCopyAccelerationStructureToMemoryInfoKHR *>( &info ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::copyMemoryToAccelerationStructureKHR(
+    const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR * pInfo,
+    Dispatch const &                                                       d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdCopyMemoryToAccelerationStructureKHR(
+      m_commandBuffer, reinterpret_cast<const VkCopyMemoryToAccelerationStructureInfoKHR *>( pInfo ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    CommandBuffer::copyMemoryToAccelerationStructureKHR( const CopyMemoryToAccelerationStructureInfoKHR & info,
+                                                         Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdCopyMemoryToAccelerationStructureKHR(
+      m_commandBuffer, reinterpret_cast<const VkCopyMemoryToAccelerationStructureInfoKHR *>( &info ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE DeviceAddress Device::getAccelerationStructureAddressKHR(
+    const VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR * pInfo,
+    Dispatch const &                                                        d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<DeviceAddress>( d.vkGetAccelerationStructureDeviceAddressKHR(
+      m_device, reinterpret_cast<const VkAccelerationStructureDeviceAddressInfoKHR *>( pInfo ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE DeviceAddress Device::getAccelerationStructureAddressKHR(
+    const AccelerationStructureDeviceAddressInfoKHR & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return d.vkGetAccelerationStructureDeviceAddressKHR(
+      m_device, reinterpret_cast<const VkAccelerationStructureDeviceAddressInfoKHR *>( &info ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesKHR(
+    uint32_t                                               accelerationStructureCount,
+    const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR * pAccelerationStructures,
+    VULKAN_HPP_NAMESPACE::QueryType                        queryType,
+    VULKAN_HPP_NAMESPACE::QueryPool                        queryPool,
+    uint32_t                                               firstQuery,
+    Dispatch const &                                       d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdWriteAccelerationStructuresPropertiesKHR(
+      m_commandBuffer,
+      accelerationStructureCount,
+      reinterpret_cast<const VkAccelerationStructureKHR *>( pAccelerationStructures ),
+      static_cast<VkQueryType>( queryType ),
+      static_cast<VkQueryPool>( queryPool ),
+      firstQuery );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesKHR(
+    ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
+    VULKAN_HPP_NAMESPACE::QueryType                                          queryType,
+    VULKAN_HPP_NAMESPACE::QueryPool                                          queryPool,
+    uint32_t                                                                 firstQuery,
+    Dispatch const &                                                         d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdWriteAccelerationStructuresPropertiesKHR(
+      m_commandBuffer,
+      accelerationStructures.size(),
+      reinterpret_cast<const VkAccelerationStructureKHR *>( accelerationStructures.data() ),
+      static_cast<VkQueryType>( queryType ),
+      static_cast<VkQueryPool>( queryPool ),
+      firstQuery );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::getAccelerationStructureCompatibilityKHR(
+    const VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR * pVersionInfo,
+    VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR *     pCompatibility,
+    Dispatch const &                                                  d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkGetDeviceAccelerationStructureCompatibilityKHR(
+      m_device,
+      reinterpret_cast<const VkAccelerationStructureVersionInfoKHR *>( pVersionInfo ),
+      reinterpret_cast<VkAccelerationStructureCompatibilityKHR *>( pCompatibility ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR
+    Device::getAccelerationStructureCompatibilityKHR( const AccelerationStructureVersionInfoKHR & versionInfo,
+                                                      Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR compatibility;
+    d.vkGetDeviceAccelerationStructureCompatibilityKHR(
+      m_device,
+      reinterpret_cast<const VkAccelerationStructureVersionInfoKHR *>( &versionInfo ),
+      reinterpret_cast<VkAccelerationStructureCompatibilityKHR *>( &compatibility ) );
+    return compatibility;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::getAccelerationStructureBuildSizesKHR(
+    VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR                 buildType,
+    const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR * pBuildInfo,
+    const uint32_t *                                                        pMaxPrimitiveCounts,
+    VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR *          pSizeInfo,
+    Dispatch const &                                                        d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkGetAccelerationStructureBuildSizesKHR(
+      m_device,
+      static_cast<VkAccelerationStructureBuildTypeKHR>( buildType ),
+      reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( pBuildInfo ),
+      pMaxPrimitiveCounts,
+      reinterpret_cast<VkAccelerationStructureBuildSizesInfoKHR *>( pSizeInfo ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR
+    Device::getAccelerationStructureBuildSizesKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType,
+                                                   const AccelerationStructureBuildGeometryInfoKHR &       buildInfo,
+                                                   ArrayProxy<const uint32_t> const & maxPrimitiveCounts,
+                                                   Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
+  {
+#  ifdef VULKAN_HPP_NO_EXCEPTIONS
+    VULKAN_HPP_ASSERT( maxPrimitiveCounts.size() == buildInfo.geometryCount );
+#  else
+    if ( maxPrimitiveCounts.size() != buildInfo.geometryCount )
+    {
+      throw LogicError(
+        VULKAN_HPP_NAMESPACE_STRING
+        "::Device::getAccelerationStructureBuildSizesKHR: maxPrimitiveCounts.size() != buildInfo.geometryCount" );
+    }
+#  endif /*VULKAN_HPP_NO_EXCEPTIONS*/
+    VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR sizeInfo;
+    d.vkGetAccelerationStructureBuildSizesKHR(
+      m_device,
+      static_cast<VkAccelerationStructureBuildTypeKHR>( buildType ),
+      reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( &buildInfo ),
+      maxPrimitiveCounts.data(),
+      reinterpret_cast<VkAccelerationStructureBuildSizesInfoKHR *>( &sizeInfo ) );
+    return sizeInfo;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  //=== VK_KHR_sampler_ycbcr_conversion ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::createSamplerYcbcrConversionKHR( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo * pCreateInfo,
+                                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks *              pAllocator,
+                                             VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion * pYcbcrConversion,
+                                             Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkCreateSamplerYcbcrConversionKHR( m_device,
+                                           reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo *>( pCreateInfo ),
+                                           reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
+                                           reinterpret_cast<VkSamplerYcbcrConversion *>( pYcbcrConversion ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>::type
+    Device::createSamplerYcbcrConversionKHR( const SamplerYcbcrConversionCreateInfo & createInfo,
+                                             Optional<const AllocationCallbacks>      allocator,
+                                             Dispatch const &                         d ) const
+  {
+    VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion;
+    Result                                       result = static_cast<Result>( d.vkCreateSamplerYcbcrConversionKHR(
+      m_device,
+      reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo *>( &createInfo ),
+      reinterpret_cast<const VkAllocationCallbacks *>(
+        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+      reinterpret_cast<VkSamplerYcbcrConversion *>( &ycbcrConversion ) ) );
+    return createResultValue(
+      result, ycbcrConversion, VULKAN_HPP_NAMESPACE_STRING "::Device::createSamplerYcbcrConversionKHR" );
+  }
+
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, Dispatch>>::type
+    Device::createSamplerYcbcrConversionKHRUnique( const SamplerYcbcrConversionCreateInfo & createInfo,
+                                                   Optional<const AllocationCallbacks>      allocator,
+                                                   Dispatch const &                         d ) const
+  {
+    VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion;
+    Result                                       result = static_cast<Result>( d.vkCreateSamplerYcbcrConversionKHR(
+      m_device,
+      reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo *>( &createInfo ),
+      reinterpret_cast<const VkAllocationCallbacks *>(
+        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+      reinterpret_cast<VkSamplerYcbcrConversion *>( &ycbcrConversion ) ) );
+    ObjectDestroy<Device, Dispatch>              deleter( *this, allocator, d );
+    return createResultValue<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, Dispatch>(
+      result, ycbcrConversion, VULKAN_HPP_NAMESPACE_STRING "::Device::createSamplerYcbcrConversionKHRUnique", deleter );
+  }
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    Device::destroySamplerYcbcrConversionKHR( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion      ycbcrConversion,
+                                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                              Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroySamplerYcbcrConversionKHR( 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::destroySamplerYcbcrConversionKHR( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion,
+                                              Optional<const AllocationCallbacks>          allocator,
+                                              Dispatch const &                             d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroySamplerYcbcrConversionKHR(
+      m_device,
+      static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ),
+      reinterpret_cast<const VkAllocationCallbacks *>(
+        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  //=== VK_KHR_bind_memory2 ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::bindBufferMemory2KHR( uint32_t                                           bindInfoCount,
+                                  const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo * pBindInfos,
+                                  Dispatch const &                                   d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkBindBufferMemory2KHR(
+      m_device, bindInfoCount, reinterpret_cast<const VkBindBufferMemoryInfo *>( pBindInfos ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
+    Device::bindBufferMemory2KHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos,
+                                  Dispatch const &                                                     d ) const
+  {
+    Result result = static_cast<Result>( d.vkBindBufferMemory2KHR(
+      m_device, bindInfos.size(), reinterpret_cast<const VkBindBufferMemoryInfo *>( bindInfos.data() ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindBufferMemory2KHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::bindImageMemory2KHR( uint32_t                                          bindInfoCount,
+                                 const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo * pBindInfos,
+                                 Dispatch const &                                  d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkBindImageMemory2KHR(
+      m_device, bindInfoCount, reinterpret_cast<const VkBindImageMemoryInfo *>( pBindInfos ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
+    Device::bindImageMemory2KHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos,
+                                 Dispatch const &                                                    d ) const
+  {
+    Result result = static_cast<Result>( d.vkBindImageMemory2KHR(
+      m_device, bindInfos.size(), reinterpret_cast<const VkBindImageMemoryInfo *>( bindInfos.data() ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindImageMemory2KHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  //=== VK_EXT_image_drm_format_modifier ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getImageDrmFormatModifierPropertiesEXT(
+    VULKAN_HPP_NAMESPACE::Image                                 image,
+    VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT * pProperties,
+    Dispatch const &                                            d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkGetImageDrmFormatModifierPropertiesEXT(
+      m_device,
+      static_cast<VkImage>( image ),
+      reinterpret_cast<VkImageDrmFormatModifierPropertiesEXT *>( pProperties ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT>::type
+    Device::getImageDrmFormatModifierPropertiesEXT( VULKAN_HPP_NAMESPACE::Image image, Dispatch const & d ) const
+  {
+    VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT properties;
+    Result result = static_cast<Result>( d.vkGetImageDrmFormatModifierPropertiesEXT(
+      m_device,
+      static_cast<VkImage>( image ),
+      reinterpret_cast<VkImageDrmFormatModifierPropertiesEXT *>( &properties ) ) );
+    return createResultValue(
+      result, properties, VULKAN_HPP_NAMESPACE_STRING "::Device::getImageDrmFormatModifierPropertiesEXT" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  //=== VK_EXT_validation_cache ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::createValidationCacheEXT( const VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT * pCreateInfo,
+                                      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *          pAllocator,
+                                      VULKAN_HPP_NAMESPACE::ValidationCacheEXT *                 pValidationCache,
+                                      Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkCreateValidationCacheEXT( m_device,
+                                    reinterpret_cast<const VkValidationCacheCreateInfoEXT *>( pCreateInfo ),
+                                    reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
+                                    reinterpret_cast<VkValidationCacheEXT *>( pValidationCache ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::ValidationCacheEXT>::type
+    Device::createValidationCacheEXT( const ValidationCacheCreateInfoEXT & createInfo,
+                                      Optional<const AllocationCallbacks>  allocator,
+                                      Dispatch const &                     d ) const
+  {
+    VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache;
+    Result                                   result = static_cast<Result>(
+      d.vkCreateValidationCacheEXT( m_device,
+                                    reinterpret_cast<const VkValidationCacheCreateInfoEXT *>( &createInfo ),
+                                    reinterpret_cast<const VkAllocationCallbacks *>(
+                                      static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                    reinterpret_cast<VkValidationCacheEXT *>( &validationCache ) ) );
+    return createResultValue(
+      result, validationCache, VULKAN_HPP_NAMESPACE_STRING "::Device::createValidationCacheEXT" );
+  }
+
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ValidationCacheEXT, Dispatch>>::type
+    Device::createValidationCacheEXTUnique( const ValidationCacheCreateInfoEXT & createInfo,
+                                            Optional<const AllocationCallbacks>  allocator,
+                                            Dispatch const &                     d ) const
+  {
+    VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache;
+    Result                                   result = static_cast<Result>(
+      d.vkCreateValidationCacheEXT( m_device,
+                                    reinterpret_cast<const VkValidationCacheCreateInfoEXT *>( &createInfo ),
+                                    reinterpret_cast<const VkAllocationCallbacks *>(
+                                      static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                    reinterpret_cast<VkValidationCacheEXT *>( &validationCache ) ) );
+    ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
+    return createResultValue<VULKAN_HPP_NAMESPACE::ValidationCacheEXT, Dispatch>(
+      result, validationCache, VULKAN_HPP_NAMESPACE_STRING "::Device::createValidationCacheEXTUnique", deleter );
+  }
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    Device::destroyValidationCacheEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT          validationCache,
+                                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                       Dispatch const &                                  d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyValidationCacheEXT( m_device,
+                                   static_cast<VkValidationCacheEXT>( validationCache ),
+                                   reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyValidationCacheEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache,
+                                                            Optional<const AllocationCallbacks>      allocator,
+                                                            Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyValidationCacheEXT( m_device,
+                                   static_cast<VkValidationCacheEXT>( validationCache ),
+                                   reinterpret_cast<const VkAllocationCallbacks *>(
+                                     static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::ValidationCacheEXT          validationCache,
+                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyValidationCacheEXT( m_device,
+                                   static_cast<VkValidationCacheEXT>( validationCache ),
+                                   reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache,
+                                          Optional<const AllocationCallbacks>      allocator,
+                                          Dispatch const &                         d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyValidationCacheEXT( m_device,
+                                   static_cast<VkValidationCacheEXT>( validationCache ),
+                                   reinterpret_cast<const VkAllocationCallbacks *>(
+                                     static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::mergeValidationCachesEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT         dstCache,
+                                      uint32_t                                         srcCacheCount,
+                                      const VULKAN_HPP_NAMESPACE::ValidationCacheEXT * pSrcCaches,
+                                      Dispatch const &                                 d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkMergeValidationCachesEXT( m_device,
+                                    static_cast<VkValidationCacheEXT>( dstCache ),
+                                    srcCacheCount,
+                                    reinterpret_cast<const VkValidationCacheEXT *>( pSrcCaches ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
+    Device::mergeValidationCachesEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT                           dstCache,
+                                      ArrayProxy<const VULKAN_HPP_NAMESPACE::ValidationCacheEXT> const & srcCaches,
+                                      Dispatch const &                                                   d ) const
+  {
+    Result result = static_cast<Result>(
+      d.vkMergeValidationCachesEXT( m_device,
+                                    static_cast<VkValidationCacheEXT>( dstCache ),
+                                    srcCaches.size(),
+                                    reinterpret_cast<const VkValidationCacheEXT *>( srcCaches.data() ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::mergeValidationCachesEXT" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::getValidationCacheDataEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache,
+                                       size_t *                                 pDataSize,
+                                       void *                                   pData,
+                                       Dispatch const &                         d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkGetValidationCacheDataEXT(
+      m_device, static_cast<VkValidationCacheEXT>( validationCache ), pDataSize, pData ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Uint8_tAllocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
+                       Device::getValidationCacheDataEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache,
+                                       Dispatch const &                         d ) const
+  {
+    std::vector<uint8_t, Uint8_tAllocator> data;
+    size_t                                 dataSize;
+    Result                                 result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetValidationCacheDataEXT(
+        m_device, static_cast<VkValidationCacheEXT>( validationCache ), &dataSize, nullptr ) );
+      if ( ( result == Result::eSuccess ) && dataSize )
+      {
+        data.resize( dataSize );
+        result =
+          static_cast<Result>( d.vkGetValidationCacheDataEXT( m_device,
+                                                              static_cast<VkValidationCacheEXT>( validationCache ),
+                                                              &dataSize,
+                                                              reinterpret_cast<void *>( data.data() ) ) );
+        VULKAN_HPP_ASSERT( dataSize <= data.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( dataSize < data.size() ) )
+    {
+      data.resize( dataSize );
+    }
+    return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getValidationCacheDataEXT" );
+  }
+
+  template <typename Uint8_tAllocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, uint8_t>::value, int>::type>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
+                       Device::getValidationCacheDataEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache,
+                                       Uint8_tAllocator &                       uint8_tAllocator,
+                                       Dispatch const &                         d ) const
+  {
+    std::vector<uint8_t, Uint8_tAllocator> data( uint8_tAllocator );
+    size_t                                 dataSize;
+    Result                                 result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetValidationCacheDataEXT(
+        m_device, static_cast<VkValidationCacheEXT>( validationCache ), &dataSize, nullptr ) );
+      if ( ( result == Result::eSuccess ) && dataSize )
+      {
+        data.resize( dataSize );
+        result =
+          static_cast<Result>( d.vkGetValidationCacheDataEXT( m_device,
+                                                              static_cast<VkValidationCacheEXT>( validationCache ),
+                                                              &dataSize,
+                                                              reinterpret_cast<void *>( data.data() ) ) );
+        VULKAN_HPP_ASSERT( dataSize <= data.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( dataSize < data.size() ) )
+    {
+      data.resize( dataSize );
+    }
+    return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getValidationCacheDataEXT" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  //=== VK_NV_shading_rate_image ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::bindShadingRateImageNV( VULKAN_HPP_NAMESPACE::ImageView   imageView,
+                                                                VULKAN_HPP_NAMESPACE::ImageLayout imageLayout,
+                                                                Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdBindShadingRateImageNV(
+      m_commandBuffer, static_cast<VkImageView>( imageView ), static_cast<VkImageLayout>( imageLayout ) );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setViewportShadingRatePaletteNV(
+    uint32_t                                           firstViewport,
+    uint32_t                                           viewportCount,
+    const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV * pShadingRatePalettes,
+    Dispatch const &                                   d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetViewportShadingRatePaletteNV( m_commandBuffer,
+                                            firstViewport,
+                                            viewportCount,
+                                            reinterpret_cast<const VkShadingRatePaletteNV *>( pShadingRatePalettes ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setViewportShadingRatePaletteNV(
+    uint32_t                                                             firstViewport,
+    ArrayProxy<const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV> const & shadingRatePalettes,
+    Dispatch const &                                                     d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetViewportShadingRatePaletteNV(
+      m_commandBuffer,
+      firstViewport,
+      shadingRatePalettes.size(),
+      reinterpret_cast<const VkShadingRatePaletteNV *>( shadingRatePalettes.data() ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    CommandBuffer::setCoarseSampleOrderNV( VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV sampleOrderType,
+                                           uint32_t                                      customSampleOrderCount,
+                                           const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV * pCustomSampleOrders,
+                                           Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetCoarseSampleOrderNV( m_commandBuffer,
+                                   static_cast<VkCoarseSampleOrderTypeNV>( sampleOrderType ),
+                                   customSampleOrderCount,
+                                   reinterpret_cast<const VkCoarseSampleOrderCustomNV *>( pCustomSampleOrders ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setCoarseSampleOrderNV(
+    VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV                             sampleOrderType,
+    ArrayProxy<const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV> const & customSampleOrders,
+    Dispatch const &                                                          d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetCoarseSampleOrderNV( m_commandBuffer,
+                                   static_cast<VkCoarseSampleOrderTypeNV>( sampleOrderType ),
+                                   customSampleOrders.size(),
+                                   reinterpret_cast<const VkCoarseSampleOrderCustomNV *>( customSampleOrders.data() ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  //=== VK_NV_ray_tracing ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::createAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV * pCreateInfo,
+                                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks *               pAllocator,
+                                           VULKAN_HPP_NAMESPACE::AccelerationStructureNV * pAccelerationStructure,
+                                           Dispatch const &                                d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkCreateAccelerationStructureNV( m_device,
+                                         reinterpret_cast<const VkAccelerationStructureCreateInfoNV *>( pCreateInfo ),
+                                         reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
+                                         reinterpret_cast<VkAccelerationStructureNV *>( pAccelerationStructure ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::AccelerationStructureNV>::type
+    Device::createAccelerationStructureNV( const AccelerationStructureCreateInfoNV & createInfo,
+                                           Optional<const AllocationCallbacks>       allocator,
+                                           Dispatch const &                          d ) const
+  {
+    VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure;
+    Result                                        result = static_cast<Result>( d.vkCreateAccelerationStructureNV(
+      m_device,
+      reinterpret_cast<const VkAccelerationStructureCreateInfoNV *>( &createInfo ),
+      reinterpret_cast<const VkAllocationCallbacks *>(
+        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+      reinterpret_cast<VkAccelerationStructureNV *>( &accelerationStructure ) ) );
+    return createResultValue(
+      result, accelerationStructure, VULKAN_HPP_NAMESPACE_STRING "::Device::createAccelerationStructureNV" );
+  }
+
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::AccelerationStructureNV, Dispatch>>::type
+    Device::createAccelerationStructureNVUnique( const AccelerationStructureCreateInfoNV & createInfo,
+                                                 Optional<const AllocationCallbacks>       allocator,
+                                                 Dispatch const &                          d ) const
+  {
+    VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure;
+    Result                                        result = static_cast<Result>( d.vkCreateAccelerationStructureNV(
+      m_device,
+      reinterpret_cast<const VkAccelerationStructureCreateInfoNV *>( &createInfo ),
+      reinterpret_cast<const VkAllocationCallbacks *>(
+        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+      reinterpret_cast<VkAccelerationStructureNV *>( &accelerationStructure ) ) );
+    ObjectDestroy<Device, Dispatch>               deleter( *this, allocator, d );
+    return createResultValue<VULKAN_HPP_NAMESPACE::AccelerationStructureNV, Dispatch>(
+      result,
+      accelerationStructure,
+      VULKAN_HPP_NAMESPACE_STRING "::Device::createAccelerationStructureNVUnique",
+      deleter );
+  }
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    Device::destroyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV     accelerationStructure,
+                                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                            Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyAccelerationStructureNV( m_device,
+                                        static_cast<VkAccelerationStructureNV>( accelerationStructure ),
+                                        reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    Device::destroyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
+                                            Optional<const AllocationCallbacks>           allocator,
+                                            Dispatch const &                              d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyAccelerationStructureNV(
+      m_device,
+      static_cast<VkAccelerationStructureNV>( accelerationStructure ),
+      reinterpret_cast<const VkAllocationCallbacks *>(
+        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureNV     accelerationStructure,
+                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyAccelerationStructureNV( m_device,
+                                        static_cast<VkAccelerationStructureNV>( accelerationStructure ),
+                                        reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
+                                          Optional<const AllocationCallbacks>           allocator,
+                                          Dispatch const &                              d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyAccelerationStructureNV(
+      m_device,
+      static_cast<VkAccelerationStructureNV>( accelerationStructure ),
+      reinterpret_cast<const VkAllocationCallbacks *>(
+        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::getAccelerationStructureMemoryRequirementsNV(
+    const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV * pInfo,
+    VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR *                              pMemoryRequirements,
+    Dispatch const &                                                            d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkGetAccelerationStructureMemoryRequirementsNV(
+      m_device,
+      reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoNV *>( pInfo ),
+      reinterpret_cast<VkMemoryRequirements2KHR *>( pMemoryRequirements ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR
+    Device::getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV & info,
+                                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR memoryRequirements;
+    d.vkGetAccelerationStructureMemoryRequirementsNV(
+      m_device,
+      reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoNV *>( &info ),
+      reinterpret_cast<VkMemoryRequirements2KHR *>( &memoryRequirements ) );
+    return memoryRequirements;
+  }
+
+  template <typename X, typename Y, typename... Z, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
+    Device::getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV & info,
+                                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    StructureChain<X, Y, Z...>                     structureChain;
+    VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR & memoryRequirements =
+      structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR>();
+    d.vkGetAccelerationStructureMemoryRequirementsNV(
+      m_device,
+      reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoNV *>( &info ),
+      reinterpret_cast<VkMemoryRequirements2KHR *>( &memoryRequirements ) );
+    return structureChain;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::bindAccelerationStructureMemoryNV(
+    uint32_t                                                            bindInfoCount,
+    const VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV * pBindInfos,
+    Dispatch const &                                                    d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkBindAccelerationStructureMemoryNV(
+      m_device, bindInfoCount, reinterpret_cast<const VkBindAccelerationStructureMemoryInfoNV *>( pBindInfos ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
+                                          Device::bindAccelerationStructureMemoryNV(
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV> const & bindInfos,
+      Dispatch const &                                                                      d ) const
+  {
+    Result result = static_cast<Result>( d.vkBindAccelerationStructureMemoryNV(
+      m_device,
+      bindInfos.size(),
+      reinterpret_cast<const VkBindAccelerationStructureMemoryInfoNV *>( bindInfos.data() ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindAccelerationStructureMemoryNV" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    CommandBuffer::buildAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV * pInfo,
+                                                 VULKAN_HPP_NAMESPACE::Buffer                              instanceData,
+                                                 VULKAN_HPP_NAMESPACE::DeviceSize              instanceOffset,
+                                                 VULKAN_HPP_NAMESPACE::Bool32                  update,
+                                                 VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst,
+                                                 VULKAN_HPP_NAMESPACE::AccelerationStructureNV src,
+                                                 VULKAN_HPP_NAMESPACE::Buffer                  scratch,
+                                                 VULKAN_HPP_NAMESPACE::DeviceSize              scratchOffset,
+                                                 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdBuildAccelerationStructureNV( m_commandBuffer,
+                                         reinterpret_cast<const VkAccelerationStructureInfoNV *>( pInfo ),
+                                         static_cast<VkBuffer>( instanceData ),
+                                         static_cast<VkDeviceSize>( instanceOffset ),
+                                         static_cast<VkBool32>( update ),
+                                         static_cast<VkAccelerationStructureNV>( dst ),
+                                         static_cast<VkAccelerationStructureNV>( src ),
+                                         static_cast<VkBuffer>( scratch ),
+                                         static_cast<VkDeviceSize>( scratchOffset ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructureNV( const AccelerationStructureInfoNV & info,
+                                                                      VULKAN_HPP_NAMESPACE::Buffer        instanceData,
+                                                                      VULKAN_HPP_NAMESPACE::DeviceSize instanceOffset,
+                                                                      VULKAN_HPP_NAMESPACE::Bool32     update,
+                                                                      VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst,
+                                                                      VULKAN_HPP_NAMESPACE::AccelerationStructureNV src,
+                                                                      VULKAN_HPP_NAMESPACE::Buffer     scratch,
+                                                                      VULKAN_HPP_NAMESPACE::DeviceSize scratchOffset,
+                                                                      Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdBuildAccelerationStructureNV( m_commandBuffer,
+                                         reinterpret_cast<const VkAccelerationStructureInfoNV *>( &info ),
+                                         static_cast<VkBuffer>( instanceData ),
+                                         static_cast<VkDeviceSize>( instanceOffset ),
+                                         static_cast<VkBool32>( update ),
+                                         static_cast<VkAccelerationStructureNV>( dst ),
+                                         static_cast<VkAccelerationStructureNV>( src ),
+                                         static_cast<VkBuffer>( scratch ),
+                                         static_cast<VkDeviceSize>( scratchOffset ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    CommandBuffer::copyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV          dst,
+                                                VULKAN_HPP_NAMESPACE::AccelerationStructureNV          src,
+                                                VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR mode,
+                                                Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdCopyAccelerationStructureNV( m_commandBuffer,
+                                        static_cast<VkAccelerationStructureNV>( dst ),
+                                        static_cast<VkAccelerationStructureNV>( src ),
+                                        static_cast<VkCopyAccelerationStructureModeKHR>( mode ) );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::traceRaysNV( VULKAN_HPP_NAMESPACE::Buffer     raygenShaderBindingTableBuffer,
+                                                     VULKAN_HPP_NAMESPACE::DeviceSize raygenShaderBindingOffset,
+                                                     VULKAN_HPP_NAMESPACE::Buffer     missShaderBindingTableBuffer,
+                                                     VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingOffset,
+                                                     VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingStride,
+                                                     VULKAN_HPP_NAMESPACE::Buffer     hitShaderBindingTableBuffer,
+                                                     VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingOffset,
+                                                     VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingStride,
+                                                     VULKAN_HPP_NAMESPACE::Buffer     callableShaderBindingTableBuffer,
+                                                     VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingOffset,
+                                                     VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingStride,
+                                                     uint32_t                         width,
+                                                     uint32_t                         height,
+                                                     uint32_t                         depth,
+                                                     Dispatch const &                 d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdTraceRaysNV( m_commandBuffer,
+                        static_cast<VkBuffer>( raygenShaderBindingTableBuffer ),
+                        static_cast<VkDeviceSize>( raygenShaderBindingOffset ),
+                        static_cast<VkBuffer>( missShaderBindingTableBuffer ),
+                        static_cast<VkDeviceSize>( missShaderBindingOffset ),
+                        static_cast<VkDeviceSize>( missShaderBindingStride ),
+                        static_cast<VkBuffer>( hitShaderBindingTableBuffer ),
+                        static_cast<VkDeviceSize>( hitShaderBindingOffset ),
+                        static_cast<VkDeviceSize>( hitShaderBindingStride ),
+                        static_cast<VkBuffer>( callableShaderBindingTableBuffer ),
+                        static_cast<VkDeviceSize>( callableShaderBindingOffset ),
+                        static_cast<VkDeviceSize>( callableShaderBindingStride ),
+                        width,
+                        height,
+                        depth );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::createRayTracingPipelinesNV( VULKAN_HPP_NAMESPACE::PipelineCache                          pipelineCache,
+                                         uint32_t                                                     createInfoCount,
+                                         const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV * pCreateInfos,
+                                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks *            pAllocator,
+                                         VULKAN_HPP_NAMESPACE::Pipeline *                             pPipelines,
+                                         Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkCreateRayTracingPipelinesNV( m_device,
+                                       static_cast<VkPipelineCache>( pipelineCache ),
+                                       createInfoCount,
+                                       reinterpret_cast<const VkRayTracingPipelineCreateInfoNV *>( pCreateInfos ),
+                                       reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
+                                       reinterpret_cast<VkPipeline *>( pPipelines ) ) );
   }
 
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename PipelineAllocator, typename Dispatch>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<Pipeline, PipelineAllocator>>
-                                         Device::createGraphicsPipelines(
-      VULKAN_HPP_NAMESPACE::PipelineCache                                        pipelineCache,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
-      Optional<const AllocationCallbacks>                                        allocator,
-      Dispatch const &                                                           d ) const
+                                         Device::createRayTracingPipelinesNV(
+      VULKAN_HPP_NAMESPACE::PipelineCache                                            pipelineCache,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
+      Optional<const AllocationCallbacks>                                            allocator,
+      Dispatch const &                                                               d ) const
   {
     std::vector<Pipeline, PipelineAllocator> pipelines( createInfos.size() );
     Result                                   result = static_cast<Result>(
-      d.vkCreateGraphicsPipelines( m_device,
-                                   static_cast<VkPipelineCache>( pipelineCache ),
-                                   createInfos.size(),
-                                   reinterpret_cast<const VkGraphicsPipelineCreateInfo *>( createInfos.data() ),
-                                   reinterpret_cast<const VkAllocationCallbacks *>(
-                                     static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                   reinterpret_cast<VkPipeline *>( pipelines.data() ) ) );
+      d.vkCreateRayTracingPipelinesNV( m_device,
+                                       static_cast<VkPipelineCache>( pipelineCache ),
+                                       createInfos.size(),
+                                       reinterpret_cast<const VkRayTracingPipelineCreateInfoNV *>( createInfos.data() ),
+                                       reinterpret_cast<const VkAllocationCallbacks *>(
+                                         static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                       reinterpret_cast<VkPipeline *>( pipelines.data() ) ) );
     return createResultValue(
       result,
       pipelines,
-      VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelines",
+      VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNV",
       { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
   }
 
@@ -106726,71 +115975,71 @@ namespace VULKAN_HPP_NAMESPACE
             typename B,
             typename std::enable_if<std::is_same<typename B::value_type, Pipeline>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<Pipeline, PipelineAllocator>>
-                                         Device::createGraphicsPipelines(
-      VULKAN_HPP_NAMESPACE::PipelineCache                                        pipelineCache,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
-      Optional<const AllocationCallbacks>                                        allocator,
-      PipelineAllocator &                                                        pipelineAllocator,
-      Dispatch const &                                                           d ) const
+                                         Device::createRayTracingPipelinesNV(
+      VULKAN_HPP_NAMESPACE::PipelineCache                                            pipelineCache,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
+      Optional<const AllocationCallbacks>                                            allocator,
+      PipelineAllocator &                                                            pipelineAllocator,
+      Dispatch const &                                                               d ) const
   {
     std::vector<Pipeline, PipelineAllocator> pipelines( createInfos.size(), pipelineAllocator );
     Result                                   result = static_cast<Result>(
-      d.vkCreateGraphicsPipelines( m_device,
-                                   static_cast<VkPipelineCache>( pipelineCache ),
-                                   createInfos.size(),
-                                   reinterpret_cast<const VkGraphicsPipelineCreateInfo *>( createInfos.data() ),
-                                   reinterpret_cast<const VkAllocationCallbacks *>(
-                                     static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                   reinterpret_cast<VkPipeline *>( pipelines.data() ) ) );
+      d.vkCreateRayTracingPipelinesNV( m_device,
+                                       static_cast<VkPipelineCache>( pipelineCache ),
+                                       createInfos.size(),
+                                       reinterpret_cast<const VkRayTracingPipelineCreateInfoNV *>( createInfos.data() ),
+                                       reinterpret_cast<const VkAllocationCallbacks *>(
+                                         static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                       reinterpret_cast<VkPipeline *>( pipelines.data() ) ) );
     return createResultValue(
       result,
       pipelines,
-      VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelines",
+      VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNV",
       { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
   }
 
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<Pipeline>
-    Device::createGraphicsPipeline( VULKAN_HPP_NAMESPACE::PipelineCache                      pipelineCache,
-                                    const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo & createInfo,
-                                    Optional<const AllocationCallbacks>                      allocator,
-                                    Dispatch const &                                         d ) const
+    Device::createRayTracingPipelineNV( VULKAN_HPP_NAMESPACE::PipelineCache                          pipelineCache,
+                                        const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV & createInfo,
+                                        Optional<const AllocationCallbacks>                          allocator,
+                                        Dispatch const &                                             d ) const
   {
     Pipeline pipeline;
     Result   result = static_cast<Result>(
-      d.vkCreateGraphicsPipelines( m_device,
-                                   static_cast<VkPipelineCache>( pipelineCache ),
-                                   1,
-                                   reinterpret_cast<const VkGraphicsPipelineCreateInfo *>( &createInfo ),
-                                   reinterpret_cast<const VkAllocationCallbacks *>(
-                                     static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                   reinterpret_cast<VkPipeline *>( &pipeline ) ) );
+      d.vkCreateRayTracingPipelinesNV( m_device,
+                                       static_cast<VkPipelineCache>( pipelineCache ),
+                                       1,
+                                       reinterpret_cast<const VkRayTracingPipelineCreateInfoNV *>( &createInfo ),
+                                       reinterpret_cast<const VkAllocationCallbacks *>(
+                                         static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                       reinterpret_cast<VkPipeline *>( &pipeline ) ) );
     return createResultValue(
       result,
       pipeline,
-      VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipeline",
+      VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelineNV",
       { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
   }
 
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch, typename PipelineAllocator>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
-                                         Device::createGraphicsPipelinesUnique(
-      VULKAN_HPP_NAMESPACE::PipelineCache                                        pipelineCache,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
-      Optional<const AllocationCallbacks>                                        allocator,
-      Dispatch const &                                                           d ) const
+                                         Device::createRayTracingPipelinesNVUnique(
+      VULKAN_HPP_NAMESPACE::PipelineCache                                            pipelineCache,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
+      Optional<const AllocationCallbacks>                                            allocator,
+      Dispatch const &                                                               d ) const
   {
     std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator> uniquePipelines;
     std::vector<Pipeline>                                            pipelines( createInfos.size() );
     Result                                                           result = static_cast<Result>(
-      d.vkCreateGraphicsPipelines( m_device,
-                                   static_cast<VkPipelineCache>( pipelineCache ),
-                                   createInfos.size(),
-                                   reinterpret_cast<const VkGraphicsPipelineCreateInfo *>( createInfos.data() ),
-                                   reinterpret_cast<const VkAllocationCallbacks *>(
-                                     static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                   reinterpret_cast<VkPipeline *>( pipelines.data() ) ) );
+      d.vkCreateRayTracingPipelinesNV( m_device,
+                                       static_cast<VkPipelineCache>( pipelineCache ),
+                                       createInfos.size(),
+                                       reinterpret_cast<const VkRayTracingPipelineCreateInfoNV *>( createInfos.data() ),
+                                       reinterpret_cast<const VkAllocationCallbacks *>(
+                                         static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                       reinterpret_cast<VkPipeline *>( pipelines.data() ) ) );
     if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) ||
          ( result == VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) )
     {
@@ -106804,7 +116053,7 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValue(
       result,
       std::move( uniquePipelines ),
-      VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelinesUnique",
+      VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNVUnique",
       { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
   }
 
@@ -106814,23 +116063,23 @@ namespace VULKAN_HPP_NAMESPACE
     typename B,
     typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
-                                         Device::createGraphicsPipelinesUnique(
-      VULKAN_HPP_NAMESPACE::PipelineCache                                        pipelineCache,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
-      Optional<const AllocationCallbacks>                                        allocator,
-      PipelineAllocator &                                                        pipelineAllocator,
-      Dispatch const &                                                           d ) const
+                                         Device::createRayTracingPipelinesNVUnique(
+      VULKAN_HPP_NAMESPACE::PipelineCache                                            pipelineCache,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
+      Optional<const AllocationCallbacks>                                            allocator,
+      PipelineAllocator &                                                            pipelineAllocator,
+      Dispatch const &                                                               d ) const
   {
     std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator> uniquePipelines( pipelineAllocator );
     std::vector<Pipeline>                                            pipelines( createInfos.size() );
     Result                                                           result = static_cast<Result>(
-      d.vkCreateGraphicsPipelines( m_device,
-                                   static_cast<VkPipelineCache>( pipelineCache ),
-                                   createInfos.size(),
-                                   reinterpret_cast<const VkGraphicsPipelineCreateInfo *>( createInfos.data() ),
-                                   reinterpret_cast<const VkAllocationCallbacks *>(
-                                     static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                   reinterpret_cast<VkPipeline *>( pipelines.data() ) ) );
+      d.vkCreateRayTracingPipelinesNV( m_device,
+                                       static_cast<VkPipelineCache>( pipelineCache ),
+                                       createInfos.size(),
+                                       reinterpret_cast<const VkRayTracingPipelineCreateInfoNV *>( createInfos.data() ),
+                                       reinterpret_cast<const VkAllocationCallbacks *>(
+                                         static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                       reinterpret_cast<VkPipeline *>( pipelines.data() ) ) );
     if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) ||
          ( result == VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) )
     {
@@ -106844,31 +116093,31 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValue(
       result,
       std::move( uniquePipelines ),
-      VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelinesUnique",
+      VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNVUnique",
       { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
   }
 
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<UniqueHandle<Pipeline, Dispatch>>
-    Device::createGraphicsPipelineUnique( VULKAN_HPP_NAMESPACE::PipelineCache                      pipelineCache,
-                                          const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo & createInfo,
-                                          Optional<const AllocationCallbacks>                      allocator,
-                                          Dispatch const &                                         d ) const
+    Device::createRayTracingPipelineNVUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
+                                              const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV & createInfo,
+                                              Optional<const AllocationCallbacks>                          allocator,
+                                              Dispatch const &                                             d ) const
   {
     Pipeline pipeline;
     Result   result = static_cast<Result>(
-      d.vkCreateGraphicsPipelines( m_device,
-                                   static_cast<VkPipelineCache>( pipelineCache ),
-                                   1,
-                                   reinterpret_cast<const VkGraphicsPipelineCreateInfo *>( &createInfo ),
-                                   reinterpret_cast<const VkAllocationCallbacks *>(
-                                     static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                   reinterpret_cast<VkPipeline *>( &pipeline ) ) );
+      d.vkCreateRayTracingPipelinesNV( m_device,
+                                       static_cast<VkPipelineCache>( pipelineCache ),
+                                       1,
+                                       reinterpret_cast<const VkRayTracingPipelineCreateInfoNV *>( &createInfo ),
+                                       reinterpret_cast<const VkAllocationCallbacks *>(
+                                         static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                       reinterpret_cast<VkPipeline *>( &pipeline ) ) );
     ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
     return createResultValue<Pipeline, Dispatch>(
       result,
       pipeline,
-      VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelineUnique",
+      VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelineNVUnique",
       { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT },
       deleter );
   }
@@ -106877,109 +116126,2390 @@ namespace VULKAN_HPP_NAMESPACE
 
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::createImage( const VULKAN_HPP_NAMESPACE::ImageCreateInfo *     pCreateInfo,
-                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                         VULKAN_HPP_NAMESPACE::Image *                     pImage,
-                         Dispatch const &                                  d ) const VULKAN_HPP_NOEXCEPT
+    Device::getRayTracingShaderGroupHandlesNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
+                                               uint32_t                       firstGroup,
+                                               uint32_t                       groupCount,
+                                               size_t                         dataSize,
+                                               void *                         pData,
+                                               Dispatch const &               d ) const VULKAN_HPP_NOEXCEPT
   {
-    return static_cast<Result>( d.vkCreateImage( m_device,
-                                                 reinterpret_cast<const VkImageCreateInfo *>( pCreateInfo ),
-                                                 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
-                                                 reinterpret_cast<VkImage *>( pImage ) ) );
+    return static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesNV(
+      m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, dataSize, pData ) );
   }
 
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::Image>::type
-                                          Device::createImage( const ImageCreateInfo &             createInfo,
-                         Optional<const AllocationCallbacks> allocator,
-                         Dispatch const &                    d ) const
+  template <typename T, typename Dispatch>
+  VULKAN_HPP_DEPRECATED( "This function is deprecated. Use one of the other flavours of it." )
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<void>::type Device::getRayTracingShaderGroupHandlesNV(
+      VULKAN_HPP_NAMESPACE::Pipeline pipeline,
+      uint32_t                       firstGroup,
+      uint32_t                       groupCount,
+      ArrayProxy<T> const &          data,
+      Dispatch const &               d ) const
   {
-    VULKAN_HPP_NAMESPACE::Image image;
-    Result                      result = static_cast<Result>(
-      d.vkCreateImage( m_device,
-                       reinterpret_cast<const VkImageCreateInfo *>( &createInfo ),
-                       reinterpret_cast<const VkAllocationCallbacks *>(
-                         static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                       reinterpret_cast<VkImage *>( &image ) ) );
-    return createResultValue( result, image, VULKAN_HPP_NAMESPACE_STRING "::Device::createImage" );
+    Result result =
+      static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesNV( m_device,
+                                                                  static_cast<VkPipeline>( pipeline ),
+                                                                  firstGroup,
+                                                                  groupCount,
+                                                                  data.size() * sizeof( T ),
+                                                                  reinterpret_cast<void *>( data.data() ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandlesNV" );
   }
 
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Image, Dispatch>>::type
-    Device::createImageUnique( const ImageCreateInfo &             createInfo,
-                               Optional<const AllocationCallbacks> allocator,
-                               Dispatch const &                    d ) const
+  template <typename T, typename Allocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<std::vector<T, Allocator>>::type
+    Device::getRayTracingShaderGroupHandlesNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
+                                               uint32_t                       firstGroup,
+                                               uint32_t                       groupCount,
+                                               size_t                         dataSize,
+                                               Dispatch const &               d ) const
   {
-    VULKAN_HPP_NAMESPACE::Image image;
-    Result                      result = static_cast<Result>(
-      d.vkCreateImage( m_device,
-                       reinterpret_cast<const VkImageCreateInfo *>( &createInfo ),
-                       reinterpret_cast<const VkAllocationCallbacks *>(
-                         static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                       reinterpret_cast<VkImage *>( &image ) ) );
-    ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<VULKAN_HPP_NAMESPACE::Image, Dispatch>(
-      result, image, VULKAN_HPP_NAMESPACE_STRING "::Device::createImageUnique", deleter );
+    VULKAN_HPP_ASSERT( dataSize % sizeof( T ) == 0 );
+    std::vector<T, Allocator> data( dataSize / sizeof( T ) );
+    Result                    result =
+      static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesNV( m_device,
+                                                                  static_cast<VkPipeline>( pipeline ),
+                                                                  firstGroup,
+                                                                  groupCount,
+                                                                  data.size() * sizeof( T ),
+                                                                  reinterpret_cast<void *>( data.data() ) ) );
+    return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandlesNV" );
   }
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename T, typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<T>::type
+    Device::getRayTracingShaderGroupHandleNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
+                                              uint32_t                       firstGroup,
+                                              uint32_t                       groupCount,
+                                              Dispatch const &               d ) const
+  {
+    T      data;
+    Result result = static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesNV( m_device,
+                                                                                static_cast<VkPipeline>( pipeline ),
+                                                                                firstGroup,
+                                                                                groupCount,
+                                                                                sizeof( T ),
+                                                                                reinterpret_cast<void *>( &data ) ) );
+    return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandleNV" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::createImageView( const VULKAN_HPP_NAMESPACE::ImageViewCreateInfo * pCreateInfo,
-                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                             VULKAN_HPP_NAMESPACE::ImageView *                 pView,
-                             Dispatch const &                                  d ) const VULKAN_HPP_NOEXCEPT
+    Device::getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
+                                              size_t                                        dataSize,
+                                              void *                                        pData,
+                                              Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
-    return static_cast<Result>( d.vkCreateImageView( m_device,
-                                                     reinterpret_cast<const VkImageViewCreateInfo *>( pCreateInfo ),
-                                                     reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
-                                                     reinterpret_cast<VkImageView *>( pView ) ) );
+    return static_cast<Result>( d.vkGetAccelerationStructureHandleNV(
+      m_device, static_cast<VkAccelerationStructureNV>( accelerationStructure ), dataSize, pData ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename T, typename Dispatch>
+  VULKAN_HPP_DEPRECATED( "This function is deprecated. Use one of the other flavours of it." )
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<void>::type Device::getAccelerationStructureHandleNV(
+      VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
+      ArrayProxy<T> const &                         data,
+      Dispatch const &                              d ) const
+  {
+    Result result = static_cast<Result>(
+      d.vkGetAccelerationStructureHandleNV( m_device,
+                                            static_cast<VkAccelerationStructureNV>( accelerationStructure ),
+                                            data.size() * sizeof( T ),
+                                            reinterpret_cast<void *>( data.data() ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getAccelerationStructureHandleNV" );
+  }
+
+  template <typename T, typename Allocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<std::vector<T, Allocator>>::type
+    Device::getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
+                                              size_t                                        dataSize,
+                                              Dispatch const &                              d ) const
+  {
+    VULKAN_HPP_ASSERT( dataSize % sizeof( T ) == 0 );
+    std::vector<T, Allocator> data( dataSize / sizeof( T ) );
+    Result                    result = static_cast<Result>(
+      d.vkGetAccelerationStructureHandleNV( m_device,
+                                            static_cast<VkAccelerationStructureNV>( accelerationStructure ),
+                                            data.size() * sizeof( T ),
+                                            reinterpret_cast<void *>( data.data() ) ) );
+    return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getAccelerationStructureHandleNV" );
+  }
+
+  template <typename T, typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<T>::type
+    Device::getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
+                                              Dispatch const &                              d ) const
+  {
+    T      data;
+    Result result = static_cast<Result>(
+      d.vkGetAccelerationStructureHandleNV( m_device,
+                                            static_cast<VkAccelerationStructureNV>( accelerationStructure ),
+                                            sizeof( T ),
+                                            reinterpret_cast<void *>( &data ) ) );
+    return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getAccelerationStructureHandleNV" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesNV(
+    uint32_t                                              accelerationStructureCount,
+    const VULKAN_HPP_NAMESPACE::AccelerationStructureNV * pAccelerationStructures,
+    VULKAN_HPP_NAMESPACE::QueryType                       queryType,
+    VULKAN_HPP_NAMESPACE::QueryPool                       queryPool,
+    uint32_t                                              firstQuery,
+    Dispatch const &                                      d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdWriteAccelerationStructuresPropertiesNV(
+      m_commandBuffer,
+      accelerationStructureCount,
+      reinterpret_cast<const VkAccelerationStructureNV *>( pAccelerationStructures ),
+      static_cast<VkQueryType>( queryType ),
+      static_cast<VkQueryPool>( queryPool ),
+      firstQuery );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesNV(
+    ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureNV> const & accelerationStructures,
+    VULKAN_HPP_NAMESPACE::QueryType                                         queryType,
+    VULKAN_HPP_NAMESPACE::QueryPool                                         queryPool,
+    uint32_t                                                                firstQuery,
+    Dispatch const &                                                        d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdWriteAccelerationStructuresPropertiesNV(
+      m_commandBuffer,
+      accelerationStructures.size(),
+      reinterpret_cast<const VkAccelerationStructureNV *>( accelerationStructures.data() ),
+      static_cast<VkQueryType>( queryType ),
+      static_cast<VkQueryPool>( queryPool ),
+      firstQuery );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::compileDeferredNV(
+    VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t shader, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkCompileDeferredNV( m_device, static_cast<VkPipeline>( pipeline ), shader ) );
+  }
+#else
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
+    Device::compileDeferredNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t shader, Dispatch const & d ) const
+  {
+    Result result =
+      static_cast<Result>( d.vkCompileDeferredNV( m_device, static_cast<VkPipeline>( pipeline ), shader ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::compileDeferredNV" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  //=== VK_KHR_maintenance3 ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    Device::getDescriptorSetLayoutSupportKHR( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo * pCreateInfo,
+                                              VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport *          pSupport,
+                                              Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkGetDescriptorSetLayoutSupportKHR( m_device,
+                                          reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( pCreateInfo ),
+                                          reinterpret_cast<VkDescriptorSetLayoutSupport *>( pSupport ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport
+    Device::getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo,
+                                              Dispatch const &                      d ) const VULKAN_HPP_NOEXCEPT
+  {
+    VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport support;
+    d.vkGetDescriptorSetLayoutSupportKHR( m_device,
+                                          reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ),
+                                          reinterpret_cast<VkDescriptorSetLayoutSupport *>( &support ) );
+    return support;
+  }
+
+  template <typename X, typename Y, typename... Z, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
+    Device::getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo,
+                                              Dispatch const &                      d ) const VULKAN_HPP_NOEXCEPT
+  {
+    StructureChain<X, Y, Z...>                         structureChain;
+    VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport & support =
+      structureChain.template get<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport>();
+    d.vkGetDescriptorSetLayoutSupportKHR( m_device,
+                                          reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ),
+                                          reinterpret_cast<VkDescriptorSetLayoutSupport *>( &support ) );
+    return structureChain;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  //=== VK_KHR_draw_indirect_count ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer     buffer,
+                                                              VULKAN_HPP_NAMESPACE::DeviceSize offset,
+                                                              VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
+                                                              VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
+                                                              uint32_t                         maxDrawCount,
+                                                              uint32_t                         stride,
+                                                              Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdDrawIndirectCountKHR( m_commandBuffer,
+                                 static_cast<VkBuffer>( buffer ),
+                                 static_cast<VkDeviceSize>( offset ),
+                                 static_cast<VkBuffer>( countBuffer ),
+                                 static_cast<VkDeviceSize>( countBufferOffset ),
+                                 maxDrawCount,
+                                 stride );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer     buffer,
+                                                                     VULKAN_HPP_NAMESPACE::DeviceSize offset,
+                                                                     VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
+                                                                     VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
+                                                                     uint32_t                         maxDrawCount,
+                                                                     uint32_t                         stride,
+                                                                     Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdDrawIndexedIndirectCountKHR( m_commandBuffer,
+                                        static_cast<VkBuffer>( buffer ),
+                                        static_cast<VkDeviceSize>( offset ),
+                                        static_cast<VkBuffer>( countBuffer ),
+                                        static_cast<VkDeviceSize>( countBufferOffset ),
+                                        maxDrawCount,
+                                        stride );
+  }
+
+  //=== VK_EXT_external_memory_host ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryHostPointerPropertiesEXT(
+    VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
+    const void *                                           pHostPointer,
+    VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT * pMemoryHostPointerProperties,
+    Dispatch const &                                       d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkGetMemoryHostPointerPropertiesEXT(
+      m_device,
+      static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ),
+      pHostPointer,
+      reinterpret_cast<VkMemoryHostPointerPropertiesEXT *>( pMemoryHostPointerProperties ) ) );
   }
 
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageView>::type
-    Device::createImageView( const ImageViewCreateInfo &         createInfo,
-                             Optional<const AllocationCallbacks> allocator,
-                             Dispatch const &                    d ) const
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT>::type
+    Device::getMemoryHostPointerPropertiesEXT( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
+                                               const void *                                           pHostPointer,
+                                               Dispatch const &                                       d ) const
   {
-    VULKAN_HPP_NAMESPACE::ImageView view;
-    Result                          result = static_cast<Result>(
-      d.vkCreateImageView( m_device,
-                           reinterpret_cast<const VkImageViewCreateInfo *>( &createInfo ),
-                           reinterpret_cast<const VkAllocationCallbacks *>(
-                             static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                           reinterpret_cast<VkImageView *>( &view ) ) );
-    return createResultValue( result, view, VULKAN_HPP_NAMESPACE_STRING "::Device::createImageView" );
+    VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT memoryHostPointerProperties;
+    Result result = static_cast<Result>( d.vkGetMemoryHostPointerPropertiesEXT(
+      m_device,
+      static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ),
+      pHostPointer,
+      reinterpret_cast<VkMemoryHostPointerPropertiesEXT *>( &memoryHostPointerProperties ) ) );
+    return createResultValue(
+      result, memoryHostPointerProperties, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryHostPointerPropertiesEXT" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  //=== VK_AMD_buffer_marker ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::writeBufferMarkerAMD( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage,
+                                                              VULKAN_HPP_NAMESPACE::Buffer                dstBuffer,
+                                                              VULKAN_HPP_NAMESPACE::DeviceSize            dstOffset,
+                                                              uint32_t                                    marker,
+                                                              Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdWriteBufferMarkerAMD( m_commandBuffer,
+                                 static_cast<VkPipelineStageFlagBits>( pipelineStage ),
+                                 static_cast<VkBuffer>( dstBuffer ),
+                                 static_cast<VkDeviceSize>( dstOffset ),
+                                 marker );
+  }
+
+  //=== VK_EXT_calibrated_timestamps ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    PhysicalDevice::getCalibrateableTimeDomainsEXT( uint32_t *                            pTimeDomainCount,
+                                                    VULKAN_HPP_NAMESPACE::TimeDomainEXT * pTimeDomains,
+                                                    Dispatch const &                      d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(
+      m_physicalDevice, pTimeDomainCount, reinterpret_cast<VkTimeDomainEXT *>( pTimeDomains ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename TimeDomainEXTAllocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
+    typename ResultValueType<std::vector<TimeDomainEXT, TimeDomainEXTAllocator>>::type
+    PhysicalDevice::getCalibrateableTimeDomainsEXT( Dispatch const & d ) const
+  {
+    std::vector<TimeDomainEXT, TimeDomainEXTAllocator> timeDomains;
+    uint32_t                                           timeDomainCount;
+    Result                                             result;
+    do
+    {
+      result = static_cast<Result>(
+        d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, &timeDomainCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && timeDomainCount )
+      {
+        timeDomains.resize( timeDomainCount );
+        result = static_cast<Result>( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(
+          m_physicalDevice, &timeDomainCount, reinterpret_cast<VkTimeDomainEXT *>( timeDomains.data() ) ) );
+        VULKAN_HPP_ASSERT( timeDomainCount <= timeDomains.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( timeDomainCount < timeDomains.size() ) )
+    {
+      timeDomains.resize( timeDomainCount );
+    }
+    return createResultValue(
+      result, timeDomains, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCalibrateableTimeDomainsEXT" );
+  }
+
+  template <typename TimeDomainEXTAllocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, TimeDomainEXT>::value, int>::type>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
+    typename ResultValueType<std::vector<TimeDomainEXT, TimeDomainEXTAllocator>>::type
+    PhysicalDevice::getCalibrateableTimeDomainsEXT( TimeDomainEXTAllocator & timeDomainEXTAllocator,
+                                                    Dispatch const &         d ) const
+  {
+    std::vector<TimeDomainEXT, TimeDomainEXTAllocator> timeDomains( timeDomainEXTAllocator );
+    uint32_t                                           timeDomainCount;
+    Result                                             result;
+    do
+    {
+      result = static_cast<Result>(
+        d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, &timeDomainCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && timeDomainCount )
+      {
+        timeDomains.resize( timeDomainCount );
+        result = static_cast<Result>( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(
+          m_physicalDevice, &timeDomainCount, reinterpret_cast<VkTimeDomainEXT *>( timeDomains.data() ) ) );
+        VULKAN_HPP_ASSERT( timeDomainCount <= timeDomains.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( timeDomainCount < timeDomains.size() ) )
+    {
+      timeDomains.resize( timeDomainCount );
+    }
+    return createResultValue(
+      result, timeDomains, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCalibrateableTimeDomainsEXT" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::getCalibratedTimestampsEXT( uint32_t                                                 timestampCount,
+                                        const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT * pTimestampInfos,
+                                        uint64_t *                                               pTimestamps,
+                                        uint64_t *                                               pMaxDeviation,
+                                        Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkGetCalibratedTimestampsEXT( m_device,
+                                      timestampCount,
+                                      reinterpret_cast<const VkCalibratedTimestampInfoEXT *>( pTimestampInfos ),
+                                      pTimestamps,
+                                      pMaxDeviation ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_DEPRECATED( "This function is deprecated. Use one of the other flavours of it." )
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<uint64_t>::type Device::getCalibratedTimestampsEXT(
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT> const & timestampInfos,
+      ArrayProxy<uint64_t> const &                                               timestamps,
+      Dispatch const &                                                           d ) const
+  {
+#  ifdef VULKAN_HPP_NO_EXCEPTIONS
+    VULKAN_HPP_ASSERT( timestampInfos.size() == timestamps.size() );
+#  else
+    if ( timestampInfos.size() != timestamps.size() )
+    {
+      throw LogicError( VULKAN_HPP_NAMESPACE_STRING
+                        "::VkDevice::getCalibratedTimestampsEXT: timestampInfos.size() != timestamps.size()" );
+    }
+#  endif /*VULKAN_HPP_NO_EXCEPTIONS*/
+    uint64_t maxDeviation;
+    Result   result = static_cast<Result>(
+      d.vkGetCalibratedTimestampsEXT( m_device,
+                                      timestampInfos.size(),
+                                      reinterpret_cast<const VkCalibratedTimestampInfoEXT *>( timestampInfos.data() ),
+                                      timestamps.data(),
+                                      &maxDeviation ) );
+    return createResultValue(
+      result, maxDeviation, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsEXT" );
+  }
+
+  template <typename Uint64_tAllocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type
+    Device::getCalibratedTimestampsEXT(
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT> const & timestampInfos,
+      Dispatch const &                                                           d ) const
+  {
+    std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t> data(
+      std::piecewise_construct, std::forward_as_tuple( timestampInfos.size() ), std::forward_as_tuple( 0 ) );
+    std::vector<uint64_t, Uint64_tAllocator> & timestamps   = data.first;
+    uint64_t &                                 maxDeviation = data.second;
+    Result                                     result       = static_cast<Result>(
+      d.vkGetCalibratedTimestampsEXT( m_device,
+                                      timestampInfos.size(),
+                                      reinterpret_cast<const VkCalibratedTimestampInfoEXT *>( timestampInfos.data() ),
+                                      timestamps.data(),
+                                      &maxDeviation ) );
+    return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsEXT" );
+  }
+
+  template <typename Uint64_tAllocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, uint64_t>::value, int>::type>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type
+    Device::getCalibratedTimestampsEXT(
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT> const & timestampInfos,
+      Uint64_tAllocator &                                                        uint64_tAllocator,
+      Dispatch const &                                                           d ) const
+  {
+    std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t> data(
+      std::piecewise_construct,
+      std::forward_as_tuple( timestampInfos.size(), uint64_tAllocator ),
+      std::forward_as_tuple( 0 ) );
+    std::vector<uint64_t, Uint64_tAllocator> & timestamps   = data.first;
+    uint64_t &                                 maxDeviation = data.second;
+    Result                                     result       = static_cast<Result>(
+      d.vkGetCalibratedTimestampsEXT( m_device,
+                                      timestampInfos.size(),
+                                      reinterpret_cast<const VkCalibratedTimestampInfoEXT *>( timestampInfos.data() ),
+                                      timestamps.data(),
+                                      &maxDeviation ) );
+    return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsEXT" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  //=== VK_NV_mesh_shader ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksNV( uint32_t         taskCount,
+                                                         uint32_t         firstTask,
+                                                         Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdDrawMeshTasksNV( m_commandBuffer, taskCount, firstTask );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectNV( VULKAN_HPP_NAMESPACE::Buffer     buffer,
+                                                                 VULKAN_HPP_NAMESPACE::DeviceSize offset,
+                                                                 uint32_t                         drawCount,
+                                                                 uint32_t                         stride,
+                                                                 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdDrawMeshTasksIndirectNV(
+      m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), drawCount, stride );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    CommandBuffer::drawMeshTasksIndirectCountNV( VULKAN_HPP_NAMESPACE::Buffer     buffer,
+                                                 VULKAN_HPP_NAMESPACE::DeviceSize offset,
+                                                 VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
+                                                 VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
+                                                 uint32_t                         maxDrawCount,
+                                                 uint32_t                         stride,
+                                                 Dispatch const &                 d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdDrawMeshTasksIndirectCountNV( m_commandBuffer,
+                                         static_cast<VkBuffer>( buffer ),
+                                         static_cast<VkDeviceSize>( offset ),
+                                         static_cast<VkBuffer>( countBuffer ),
+                                         static_cast<VkDeviceSize>( countBufferOffset ),
+                                         maxDrawCount,
+                                         stride );
+  }
+
+  //=== VK_NV_scissor_exclusive ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setExclusiveScissorNV( uint32_t firstExclusiveScissor,
+                                                               uint32_t exclusiveScissorCount,
+                                                               const VULKAN_HPP_NAMESPACE::Rect2D * pExclusiveScissors,
+                                                               Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetExclusiveScissorNV( m_commandBuffer,
+                                  firstExclusiveScissor,
+                                  exclusiveScissorCount,
+                                  reinterpret_cast<const VkRect2D *>( pExclusiveScissors ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    CommandBuffer::setExclusiveScissorNV( uint32_t                                               firstExclusiveScissor,
+                                          ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & exclusiveScissors,
+                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetExclusiveScissorNV( m_commandBuffer,
+                                  firstExclusiveScissor,
+                                  exclusiveScissors.size(),
+                                  reinterpret_cast<const VkRect2D *>( exclusiveScissors.data() ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  //=== VK_NV_device_diagnostic_checkpoints ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setCheckpointNV( const void *     pCheckpointMarker,
+                                                         Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetCheckpointNV( m_commandBuffer, pCheckpointMarker );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Queue::getCheckpointDataNV( uint32_t *                               pCheckpointDataCount,
+                                                     VULKAN_HPP_NAMESPACE::CheckpointDataNV * pCheckpointData,
+                                                     Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkGetQueueCheckpointDataNV(
+      m_queue, pCheckpointDataCount, reinterpret_cast<VkCheckpointDataNV *>( pCheckpointData ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename CheckpointDataNVAllocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<CheckpointDataNV, CheckpointDataNVAllocator>
+                                         Queue::getCheckpointDataNV( Dispatch const & d ) const
+  {
+    std::vector<CheckpointDataNV, CheckpointDataNVAllocator> checkpointData;
+    uint32_t                                                 checkpointDataCount;
+    d.vkGetQueueCheckpointDataNV( m_queue, &checkpointDataCount, nullptr );
+    checkpointData.resize( checkpointDataCount );
+    d.vkGetQueueCheckpointDataNV(
+      m_queue, &checkpointDataCount, reinterpret_cast<VkCheckpointDataNV *>( checkpointData.data() ) );
+    VULKAN_HPP_ASSERT( checkpointDataCount <= checkpointData.size() );
+    return checkpointData;
+  }
+
+  template <typename CheckpointDataNVAllocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, CheckpointDataNV>::value, int>::type>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<CheckpointDataNV, CheckpointDataNVAllocator>
+    Queue::getCheckpointDataNV( CheckpointDataNVAllocator & checkpointDataNVAllocator, Dispatch const & d ) const
+  {
+    std::vector<CheckpointDataNV, CheckpointDataNVAllocator> checkpointData( checkpointDataNVAllocator );
+    uint32_t                                                 checkpointDataCount;
+    d.vkGetQueueCheckpointDataNV( m_queue, &checkpointDataCount, nullptr );
+    checkpointData.resize( checkpointDataCount );
+    d.vkGetQueueCheckpointDataNV(
+      m_queue, &checkpointDataCount, reinterpret_cast<VkCheckpointDataNV *>( checkpointData.data() ) );
+    VULKAN_HPP_ASSERT( checkpointDataCount <= checkpointData.size() );
+    return checkpointData;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  //=== VK_KHR_timeline_semaphore ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSemaphoreCounterValueKHR(
+    VULKAN_HPP_NAMESPACE::Semaphore semaphore, uint64_t * pValue, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkGetSemaphoreCounterValueKHR( m_device, static_cast<VkSemaphore>( semaphore ), pValue ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<uint64_t>::type
+    Device::getSemaphoreCounterValueKHR( VULKAN_HPP_NAMESPACE::Semaphore semaphore, Dispatch const & d ) const
+  {
+    uint64_t value;
+    Result   result =
+      static_cast<Result>( d.vkGetSemaphoreCounterValueKHR( m_device, static_cast<VkSemaphore>( semaphore ), &value ) );
+    return createResultValue( result, value, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreCounterValueKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::waitSemaphoresKHR( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo * pWaitInfo,
+                               uint64_t                                        timeout,
+                               Dispatch const &                                d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkWaitSemaphoresKHR( m_device, reinterpret_cast<const VkSemaphoreWaitInfo *>( pWaitInfo ), timeout ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::waitSemaphoresKHR( const SemaphoreWaitInfo & waitInfo,
+                                                                           uint64_t                  timeout,
+                                                                           Dispatch const &          d ) const
+  {
+    Result result = static_cast<Result>(
+      d.vkWaitSemaphoresKHR( m_device, reinterpret_cast<const VkSemaphoreWaitInfo *>( &waitInfo ), timeout ) );
+    return createResultValue( result,
+                              VULKAN_HPP_NAMESPACE_STRING "::Device::waitSemaphoresKHR",
+                              { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eTimeout } );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::signalSemaphoreKHR(
+    const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo * pSignalInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkSignalSemaphoreKHR( m_device, reinterpret_cast<const VkSemaphoreSignalInfo *>( pSignalInfo ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
+    Device::signalSemaphoreKHR( const SemaphoreSignalInfo & signalInfo, Dispatch const & d ) const
+  {
+    Result result = static_cast<Result>(
+      d.vkSignalSemaphoreKHR( m_device, reinterpret_cast<const VkSemaphoreSignalInfo *>( &signalInfo ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::signalSemaphoreKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  //=== VK_INTEL_performance_query ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::initializePerformanceApiINTEL(
+    const VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL * pInitializeInfo,
+    Dispatch const &                                                d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkInitializePerformanceApiINTEL(
+      m_device, reinterpret_cast<const VkInitializePerformanceApiInfoINTEL *>( pInitializeInfo ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
+    Device::initializePerformanceApiINTEL( const InitializePerformanceApiInfoINTEL & initializeInfo,
+                                           Dispatch const &                          d ) const
+  {
+    Result result = static_cast<Result>( d.vkInitializePerformanceApiINTEL(
+      m_device, reinterpret_cast<const VkInitializePerformanceApiInfoINTEL *>( &initializeInfo ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::initializePerformanceApiINTEL" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::uninitializePerformanceApiINTEL( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkUninitializePerformanceApiINTEL( m_device );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result CommandBuffer::setPerformanceMarkerINTEL(
+    const VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL * pMarkerInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkCmdSetPerformanceMarkerINTEL(
+      m_commandBuffer, reinterpret_cast<const VkPerformanceMarkerInfoINTEL *>( pMarkerInfo ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
+    CommandBuffer::setPerformanceMarkerINTEL( const PerformanceMarkerInfoINTEL & markerInfo, Dispatch const & d ) const
+  {
+    Result result = static_cast<Result>( d.vkCmdSetPerformanceMarkerINTEL(
+      m_commandBuffer, reinterpret_cast<const VkPerformanceMarkerInfoINTEL *>( &markerInfo ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setPerformanceMarkerINTEL" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result CommandBuffer::setPerformanceStreamMarkerINTEL(
+    const VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL * pMarkerInfo,
+    Dispatch const &                                               d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkCmdSetPerformanceStreamMarkerINTEL(
+      m_commandBuffer, reinterpret_cast<const VkPerformanceStreamMarkerInfoINTEL *>( pMarkerInfo ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
+    CommandBuffer::setPerformanceStreamMarkerINTEL( const PerformanceStreamMarkerInfoINTEL & markerInfo,
+                                                    Dispatch const &                         d ) const
+  {
+    Result result = static_cast<Result>( d.vkCmdSetPerformanceStreamMarkerINTEL(
+      m_commandBuffer, reinterpret_cast<const VkPerformanceStreamMarkerInfoINTEL *>( &markerInfo ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setPerformanceStreamMarkerINTEL" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result CommandBuffer::setPerformanceOverrideINTEL(
+    const VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL * pOverrideInfo,
+    Dispatch const &                                           d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkCmdSetPerformanceOverrideINTEL(
+      m_commandBuffer, reinterpret_cast<const VkPerformanceOverrideInfoINTEL *>( pOverrideInfo ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
+    CommandBuffer::setPerformanceOverrideINTEL( const PerformanceOverrideInfoINTEL & overrideInfo,
+                                                Dispatch const &                     d ) const
+  {
+    Result result = static_cast<Result>( d.vkCmdSetPerformanceOverrideINTEL(
+      m_commandBuffer, reinterpret_cast<const VkPerformanceOverrideInfoINTEL *>( &overrideInfo ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setPerformanceOverrideINTEL" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::acquirePerformanceConfigurationINTEL(
+    const VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL * pAcquireInfo,
+    VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL *                  pConfiguration,
+    Dispatch const &                                                       d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkAcquirePerformanceConfigurationINTEL(
+      m_device,
+      reinterpret_cast<const VkPerformanceConfigurationAcquireInfoINTEL *>( pAcquireInfo ),
+      reinterpret_cast<VkPerformanceConfigurationINTEL *>( pConfiguration ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL>::type
+    Device::acquirePerformanceConfigurationINTEL( const PerformanceConfigurationAcquireInfoINTEL & acquireInfo,
+                                                  Dispatch const &                                 d ) const
+  {
+    VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration;
+    Result result = static_cast<Result>( d.vkAcquirePerformanceConfigurationINTEL(
+      m_device,
+      reinterpret_cast<const VkPerformanceConfigurationAcquireInfoINTEL *>( &acquireInfo ),
+      reinterpret_cast<VkPerformanceConfigurationINTEL *>( &configuration ) ) );
+    return createResultValue(
+      result, configuration, VULKAN_HPP_NAMESPACE_STRING "::Device::acquirePerformanceConfigurationINTEL" );
   }
 
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ImageView, Dispatch>>::type
-    Device::createImageViewUnique( const ImageViewCreateInfo &         createInfo,
-                                   Optional<const AllocationCallbacks> allocator,
-                                   Dispatch const &                    d ) const
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL, Dispatch>>::type
+    Device::acquirePerformanceConfigurationINTELUnique( const PerformanceConfigurationAcquireInfoINTEL & acquireInfo,
+                                                        Dispatch const &                                 d ) const
   {
-    VULKAN_HPP_NAMESPACE::ImageView view;
-    Result                          result = static_cast<Result>(
-      d.vkCreateImageView( m_device,
-                           reinterpret_cast<const VkImageViewCreateInfo *>( &createInfo ),
-                           reinterpret_cast<const VkAllocationCallbacks *>(
-                             static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                           reinterpret_cast<VkImageView *>( &view ) ) );
-    ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<VULKAN_HPP_NAMESPACE::ImageView, Dispatch>(
-      result, view, VULKAN_HPP_NAMESPACE_STRING "::Device::createImageViewUnique", deleter );
+    VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration;
+    Result                          result = static_cast<Result>( d.vkAcquirePerformanceConfigurationINTEL(
+      m_device,
+      reinterpret_cast<const VkPerformanceConfigurationAcquireInfoINTEL *>( &acquireInfo ),
+      reinterpret_cast<VkPerformanceConfigurationINTEL *>( &configuration ) ) );
+    ObjectRelease<Device, Dispatch> deleter( *this, d );
+    return createResultValue<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL, Dispatch>(
+      result,
+      configuration,
+      VULKAN_HPP_NAMESPACE_STRING "::Device::acquirePerformanceConfigurationINTELUnique",
+      deleter );
   }
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::releasePerformanceConfigurationINTEL(
+    VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkReleasePerformanceConfigurationINTEL(
+      m_device, static_cast<VkPerformanceConfigurationINTEL>( configuration ) ) );
+  }
+#else
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
+    Device::releasePerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,
+                                                  Dispatch const & d ) const
+  {
+    Result result = static_cast<Result>( d.vkReleasePerformanceConfigurationINTEL(
+      m_device, static_cast<VkPerformanceConfigurationINTEL>( configuration ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::releasePerformanceConfigurationINTEL" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::release(
+    VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkReleasePerformanceConfigurationINTEL(
+      m_device, static_cast<VkPerformanceConfigurationINTEL>( configuration ) ) );
+  }
+#else
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
+    Device::release( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration, Dispatch const & d ) const
+  {
+    Result result = static_cast<Result>( d.vkReleasePerformanceConfigurationINTEL(
+      m_device, static_cast<VkPerformanceConfigurationINTEL>( configuration ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::release" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Queue::setPerformanceConfigurationINTEL(
+    VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkQueueSetPerformanceConfigurationINTEL(
+      m_queue, static_cast<VkPerformanceConfigurationINTEL>( configuration ) ) );
+  }
+#else
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
+    Queue::setPerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,
+                                             Dispatch const & d ) const
+  {
+    Result result = static_cast<Result>( d.vkQueueSetPerformanceConfigurationINTEL(
+      m_queue, static_cast<VkPerformanceConfigurationINTEL>( configuration ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::setPerformanceConfigurationINTEL" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::getPerformanceParameterINTEL( VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL parameter,
+                                          VULKAN_HPP_NAMESPACE::PerformanceValueINTEL *       pValue,
+                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkGetPerformanceParameterINTEL( m_device,
+                                        static_cast<VkPerformanceParameterTypeINTEL>( parameter ),
+                                        reinterpret_cast<VkPerformanceValueINTEL *>( pValue ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::PerformanceValueINTEL>::type
+    Device::getPerformanceParameterINTEL( VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL parameter,
+                                          Dispatch const &                                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::PerformanceValueINTEL value;
+    Result                                      result =
+      static_cast<Result>( d.vkGetPerformanceParameterINTEL( m_device,
+                                                             static_cast<VkPerformanceParameterTypeINTEL>( parameter ),
+                                                             reinterpret_cast<VkPerformanceValueINTEL *>( &value ) ) );
+    return createResultValue( result, value, VULKAN_HPP_NAMESPACE_STRING "::Device::getPerformanceParameterINTEL" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  //=== VK_AMD_display_native_hdr ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::setLocalDimmingAMD( VULKAN_HPP_NAMESPACE::SwapchainKHR swapChain,
+                                                     VULKAN_HPP_NAMESPACE::Bool32       localDimmingEnable,
+                                                     Dispatch const &                   d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkSetLocalDimmingAMD(
+      m_device, static_cast<VkSwapchainKHR>( swapChain ), static_cast<VkBool32>( localDimmingEnable ) );
+  }
+
+#if defined( VK_USE_PLATFORM_FUCHSIA )
+  //=== VK_FUCHSIA_imagepipe_surface ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createImagePipeSurfaceFUCHSIA(
+    const VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA * pCreateInfo,
+    const VULKAN_HPP_NAMESPACE::AllocationCallbacks *               pAllocator,
+    VULKAN_HPP_NAMESPACE::SurfaceKHR *                              pSurface,
+    Dispatch const &                                                d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkCreateImagePipeSurfaceFUCHSIA( m_instance,
+                                         reinterpret_cast<const VkImagePipeSurfaceCreateInfoFUCHSIA *>( pCreateInfo ),
+                                         reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
+                                         reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
+  }
+
+#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
+    Instance::createImagePipeSurfaceFUCHSIA( const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo,
+                                             Optional<const AllocationCallbacks>       allocator,
+                                             Dispatch const &                          d ) const
+  {
+    VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
+    Result                           result = static_cast<Result>( d.vkCreateImagePipeSurfaceFUCHSIA(
+      m_instance,
+      reinterpret_cast<const VkImagePipeSurfaceCreateInfoFUCHSIA *>( &createInfo ),
+      reinterpret_cast<const VkAllocationCallbacks *>(
+        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+      reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
+    return createResultValue(
+      result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createImagePipeSurfaceFUCHSIA" );
+  }
+
+#    ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
+    Instance::createImagePipeSurfaceFUCHSIAUnique( const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo,
+                                                   Optional<const AllocationCallbacks>       allocator,
+                                                   Dispatch const &                          d ) const
+  {
+    VULKAN_HPP_NAMESPACE::SurfaceKHR  surface;
+    Result                            result = static_cast<Result>( d.vkCreateImagePipeSurfaceFUCHSIA(
+      m_instance,
+      reinterpret_cast<const VkImagePipeSurfaceCreateInfoFUCHSIA *>( &createInfo ),
+      reinterpret_cast<const VkAllocationCallbacks *>(
+        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+      reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
+    ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d );
+    return createResultValue<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>(
+      result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createImagePipeSurfaceFUCHSIAUnique", deleter );
+  }
+#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif     /*VK_USE_PLATFORM_FUCHSIA*/
+
+#if defined( VK_USE_PLATFORM_METAL_EXT )
+  //=== VK_EXT_metal_surface ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Instance::createMetalSurfaceEXT( const VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT * pCreateInfo,
+                                     const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,
+                                     VULKAN_HPP_NAMESPACE::SurfaceKHR *                      pSurface,
+                                     Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkCreateMetalSurfaceEXT( m_instance,
+                                 reinterpret_cast<const VkMetalSurfaceCreateInfoEXT *>( pCreateInfo ),
+                                 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
+                                 reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
+  }
+
+#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
+    Instance::createMetalSurfaceEXT( const MetalSurfaceCreateInfoEXT &   createInfo,
+                                     Optional<const AllocationCallbacks> allocator,
+                                     Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
+    Result                           result = static_cast<Result>(
+      d.vkCreateMetalSurfaceEXT( m_instance,
+                                 reinterpret_cast<const VkMetalSurfaceCreateInfoEXT *>( &createInfo ),
+                                 reinterpret_cast<const VkAllocationCallbacks *>(
+                                   static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
+    return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createMetalSurfaceEXT" );
+  }
+
+#    ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
+    Instance::createMetalSurfaceEXTUnique( const MetalSurfaceCreateInfoEXT &   createInfo,
+                                           Optional<const AllocationCallbacks> allocator,
+                                           Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
+    Result                           result = static_cast<Result>(
+      d.vkCreateMetalSurfaceEXT( m_instance,
+                                 reinterpret_cast<const VkMetalSurfaceCreateInfoEXT *>( &createInfo ),
+                                 reinterpret_cast<const VkAllocationCallbacks *>(
+                                   static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
+    ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d );
+    return createResultValue<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>(
+      result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createMetalSurfaceEXTUnique", deleter );
+  }
+#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif     /*VK_USE_PLATFORM_METAL_EXT*/
+
+  //=== VK_KHR_fragment_shading_rate ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getFragmentShadingRatesKHR(
+    uint32_t *                                                   pFragmentShadingRateCount,
+    VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR * pFragmentShadingRates,
+    Dispatch const &                                             d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkGetPhysicalDeviceFragmentShadingRatesKHR(
+      m_physicalDevice,
+      pFragmentShadingRateCount,
+      reinterpret_cast<VkPhysicalDeviceFragmentShadingRateKHR *>( pFragmentShadingRates ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename PhysicalDeviceFragmentShadingRateKHRAllocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<
+    std::vector<PhysicalDeviceFragmentShadingRateKHR, PhysicalDeviceFragmentShadingRateKHRAllocator>>::type
+    PhysicalDevice::getFragmentShadingRatesKHR( Dispatch const & d ) const
+  {
+    std::vector<PhysicalDeviceFragmentShadingRateKHR, PhysicalDeviceFragmentShadingRateKHRAllocator>
+             fragmentShadingRates;
+    uint32_t fragmentShadingRateCount;
+    Result   result;
+    do
+    {
+      result = static_cast<Result>(
+        d.vkGetPhysicalDeviceFragmentShadingRatesKHR( m_physicalDevice, &fragmentShadingRateCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && fragmentShadingRateCount )
+      {
+        fragmentShadingRates.resize( fragmentShadingRateCount );
+        result = static_cast<Result>( d.vkGetPhysicalDeviceFragmentShadingRatesKHR(
+          m_physicalDevice,
+          &fragmentShadingRateCount,
+          reinterpret_cast<VkPhysicalDeviceFragmentShadingRateKHR *>( fragmentShadingRates.data() ) ) );
+        VULKAN_HPP_ASSERT( fragmentShadingRateCount <= fragmentShadingRates.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( fragmentShadingRateCount < fragmentShadingRates.size() ) )
+    {
+      fragmentShadingRates.resize( fragmentShadingRateCount );
+    }
+    return createResultValue(
+      result, fragmentShadingRates, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getFragmentShadingRatesKHR" );
+  }
+
+  template <typename PhysicalDeviceFragmentShadingRateKHRAllocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, PhysicalDeviceFragmentShadingRateKHR>::value,
+                                    int>::type>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<
+    std::vector<PhysicalDeviceFragmentShadingRateKHR, PhysicalDeviceFragmentShadingRateKHRAllocator>>::type
+    PhysicalDevice::getFragmentShadingRatesKHR(
+      PhysicalDeviceFragmentShadingRateKHRAllocator & physicalDeviceFragmentShadingRateKHRAllocator,
+      Dispatch const &                                d ) const
+  {
+    std::vector<PhysicalDeviceFragmentShadingRateKHR, PhysicalDeviceFragmentShadingRateKHRAllocator>
+             fragmentShadingRates( physicalDeviceFragmentShadingRateKHRAllocator );
+    uint32_t fragmentShadingRateCount;
+    Result   result;
+    do
+    {
+      result = static_cast<Result>(
+        d.vkGetPhysicalDeviceFragmentShadingRatesKHR( m_physicalDevice, &fragmentShadingRateCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && fragmentShadingRateCount )
+      {
+        fragmentShadingRates.resize( fragmentShadingRateCount );
+        result = static_cast<Result>( d.vkGetPhysicalDeviceFragmentShadingRatesKHR(
+          m_physicalDevice,
+          &fragmentShadingRateCount,
+          reinterpret_cast<VkPhysicalDeviceFragmentShadingRateKHR *>( fragmentShadingRates.data() ) ) );
+        VULKAN_HPP_ASSERT( fragmentShadingRateCount <= fragmentShadingRates.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( fragmentShadingRateCount < fragmentShadingRates.size() ) )
+    {
+      fragmentShadingRates.resize( fragmentShadingRateCount );
+    }
+    return createResultValue(
+      result, fragmentShadingRates, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getFragmentShadingRatesKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setFragmentShadingRateKHR(
+    const VULKAN_HPP_NAMESPACE::Extent2D *                       pFragmentSize,
+    const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2],
+    Dispatch const &                                             d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetFragmentShadingRateKHR( m_commandBuffer,
+                                      reinterpret_cast<const VkExtent2D *>( pFragmentSize ),
+                                      reinterpret_cast<const VkFragmentShadingRateCombinerOpKHR *>( combinerOps ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setFragmentShadingRateKHR(
+    const Extent2D &                                             fragmentSize,
+    const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2],
+    Dispatch const &                                             d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetFragmentShadingRateKHR( m_commandBuffer,
+                                      reinterpret_cast<const VkExtent2D *>( &fragmentSize ),
+                                      reinterpret_cast<const VkFragmentShadingRateCombinerOpKHR *>( combinerOps ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  //=== VK_EXT_buffer_device_address ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddressEXT(
+    const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<DeviceAddress>(
+      d.vkGetBufferDeviceAddressEXT( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo *>( pInfo ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddressEXT( const BufferDeviceAddressInfo & info,
+                                                               Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return d.vkGetBufferDeviceAddressEXT( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  //=== VK_EXT_tooling_info ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    PhysicalDevice::getToolPropertiesEXT( uint32_t *                                              pToolCount,
+                                          VULKAN_HPP_NAMESPACE::PhysicalDeviceToolPropertiesEXT * pToolProperties,
+                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkGetPhysicalDeviceToolPropertiesEXT(
+      m_physicalDevice, pToolCount, reinterpret_cast<VkPhysicalDeviceToolPropertiesEXT *>( pToolProperties ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename PhysicalDeviceToolPropertiesEXTAllocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<
+    std::vector<PhysicalDeviceToolPropertiesEXT, PhysicalDeviceToolPropertiesEXTAllocator>>::type
+    PhysicalDevice::getToolPropertiesEXT( Dispatch const & d ) const
+  {
+    std::vector<PhysicalDeviceToolPropertiesEXT, PhysicalDeviceToolPropertiesEXTAllocator> toolProperties;
+    uint32_t                                                                               toolCount;
+    Result                                                                                 result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetPhysicalDeviceToolPropertiesEXT( m_physicalDevice, &toolCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && toolCount )
+      {
+        toolProperties.resize( toolCount );
+        result = static_cast<Result>( d.vkGetPhysicalDeviceToolPropertiesEXT(
+          m_physicalDevice,
+          &toolCount,
+          reinterpret_cast<VkPhysicalDeviceToolPropertiesEXT *>( toolProperties.data() ) ) );
+        VULKAN_HPP_ASSERT( toolCount <= toolProperties.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( toolCount < toolProperties.size() ) )
+    {
+      toolProperties.resize( toolCount );
+    }
+    return createResultValue(
+      result, toolProperties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getToolPropertiesEXT" );
+  }
+
+  template <
+    typename PhysicalDeviceToolPropertiesEXTAllocator,
+    typename Dispatch,
+    typename B,
+    typename std::enable_if<std::is_same<typename B::value_type, PhysicalDeviceToolPropertiesEXT>::value, int>::type>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<
+    std::vector<PhysicalDeviceToolPropertiesEXT, PhysicalDeviceToolPropertiesEXTAllocator>>::type
+    PhysicalDevice::getToolPropertiesEXT(
+      PhysicalDeviceToolPropertiesEXTAllocator & physicalDeviceToolPropertiesEXTAllocator, Dispatch const & d ) const
+  {
+    std::vector<PhysicalDeviceToolPropertiesEXT, PhysicalDeviceToolPropertiesEXTAllocator> toolProperties(
+      physicalDeviceToolPropertiesEXTAllocator );
+    uint32_t toolCount;
+    Result   result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetPhysicalDeviceToolPropertiesEXT( m_physicalDevice, &toolCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && toolCount )
+      {
+        toolProperties.resize( toolCount );
+        result = static_cast<Result>( d.vkGetPhysicalDeviceToolPropertiesEXT(
+          m_physicalDevice,
+          &toolCount,
+          reinterpret_cast<VkPhysicalDeviceToolPropertiesEXT *>( toolProperties.data() ) ) );
+        VULKAN_HPP_ASSERT( toolCount <= toolProperties.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( toolCount < toolProperties.size() ) )
+    {
+      toolProperties.resize( toolCount );
+    }
+    return createResultValue(
+      result, toolProperties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getToolPropertiesEXT" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  //=== VK_NV_cooperative_matrix ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    PhysicalDevice::getCooperativeMatrixPropertiesNV( uint32_t * pPropertyCount,
+                                                      VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV * pProperties,
+                                                      Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(
+      m_physicalDevice, pPropertyCount, reinterpret_cast<VkCooperativeMatrixPropertiesNV *>( pProperties ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename CooperativeMatrixPropertiesNVAllocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
+    typename ResultValueType<std::vector<CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator>>::type
+    PhysicalDevice::getCooperativeMatrixPropertiesNV( Dispatch const & d ) const
+  {
+    std::vector<CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator> properties;
+    uint32_t                                                                           propertyCount;
+    Result                                                                             result;
+    do
+    {
+      result = static_cast<Result>(
+        d.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( m_physicalDevice, &propertyCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && propertyCount )
+      {
+        properties.resize( propertyCount );
+        result = static_cast<Result>( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(
+          m_physicalDevice,
+          &propertyCount,
+          reinterpret_cast<VkCooperativeMatrixPropertiesNV *>( properties.data() ) ) );
+        VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) )
+    {
+      properties.resize( propertyCount );
+    }
+    return createResultValue(
+      result, properties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCooperativeMatrixPropertiesNV" );
+  }
+
+  template <
+    typename CooperativeMatrixPropertiesNVAllocator,
+    typename Dispatch,
+    typename B,
+    typename std::enable_if<std::is_same<typename B::value_type, CooperativeMatrixPropertiesNV>::value, int>::type>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
+    typename ResultValueType<std::vector<CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator>>::type
+    PhysicalDevice::getCooperativeMatrixPropertiesNV(
+      CooperativeMatrixPropertiesNVAllocator & cooperativeMatrixPropertiesNVAllocator, Dispatch const & d ) const
+  {
+    std::vector<CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator> properties(
+      cooperativeMatrixPropertiesNVAllocator );
+    uint32_t propertyCount;
+    Result   result;
+    do
+    {
+      result = static_cast<Result>(
+        d.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( m_physicalDevice, &propertyCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && propertyCount )
+      {
+        properties.resize( propertyCount );
+        result = static_cast<Result>( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(
+          m_physicalDevice,
+          &propertyCount,
+          reinterpret_cast<VkCooperativeMatrixPropertiesNV *>( properties.data() ) ) );
+        VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) )
+    {
+      properties.resize( propertyCount );
+    }
+    return createResultValue(
+      result, properties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCooperativeMatrixPropertiesNV" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  //=== VK_NV_coverage_reduction_mode ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV(
+    uint32_t *                                                   pCombinationCount,
+    VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV * pCombinations,
+    Dispatch const &                                             d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
+      m_physicalDevice,
+      pCombinationCount,
+      reinterpret_cast<VkFramebufferMixedSamplesCombinationNV *>( pCombinations ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename FramebufferMixedSamplesCombinationNVAllocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<
+    std::vector<FramebufferMixedSamplesCombinationNV, FramebufferMixedSamplesCombinationNVAllocator>>::type
+    PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV( Dispatch const & d ) const
+  {
+    std::vector<FramebufferMixedSamplesCombinationNV, FramebufferMixedSamplesCombinationNVAllocator> combinations;
+    uint32_t                                                                                         combinationCount;
+    Result                                                                                           result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
+        m_physicalDevice, &combinationCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && combinationCount )
+      {
+        combinations.resize( combinationCount );
+        result = static_cast<Result>( d.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
+          m_physicalDevice,
+          &combinationCount,
+          reinterpret_cast<VkFramebufferMixedSamplesCombinationNV *>( combinations.data() ) ) );
+        VULKAN_HPP_ASSERT( combinationCount <= combinations.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( combinationCount < combinations.size() ) )
+    {
+      combinations.resize( combinationCount );
+    }
+    return createResultValue( result,
+                              combinations,
+                              VULKAN_HPP_NAMESPACE_STRING
+                              "::PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV" );
+  }
+
+  template <typename FramebufferMixedSamplesCombinationNVAllocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, FramebufferMixedSamplesCombinationNV>::value,
+                                    int>::type>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<
+    std::vector<FramebufferMixedSamplesCombinationNV, FramebufferMixedSamplesCombinationNVAllocator>>::type
+    PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV(
+      FramebufferMixedSamplesCombinationNVAllocator & framebufferMixedSamplesCombinationNVAllocator,
+      Dispatch const &                                d ) const
+  {
+    std::vector<FramebufferMixedSamplesCombinationNV, FramebufferMixedSamplesCombinationNVAllocator> combinations(
+      framebufferMixedSamplesCombinationNVAllocator );
+    uint32_t combinationCount;
+    Result   result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
+        m_physicalDevice, &combinationCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && combinationCount )
+      {
+        combinations.resize( combinationCount );
+        result = static_cast<Result>( d.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
+          m_physicalDevice,
+          &combinationCount,
+          reinterpret_cast<VkFramebufferMixedSamplesCombinationNV *>( combinations.data() ) ) );
+        VULKAN_HPP_ASSERT( combinationCount <= combinations.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( combinationCount < combinations.size() ) )
+    {
+      combinations.resize( combinationCount );
+    }
+    return createResultValue( result,
+                              combinations,
+                              VULKAN_HPP_NAMESPACE_STRING
+                              "::PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#if defined( VK_USE_PLATFORM_WIN32_KHR )
+  //=== VK_EXT_full_screen_exclusive ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getSurfacePresentModes2EXT(
+    const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
+    uint32_t *                                                  pPresentModeCount,
+    VULKAN_HPP_NAMESPACE::PresentModeKHR *                      pPresentModes,
+    Dispatch const &                                            d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkGetPhysicalDeviceSurfacePresentModes2EXT(
+      m_physicalDevice,
+      reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( pSurfaceInfo ),
+      pPresentModeCount,
+      reinterpret_cast<VkPresentModeKHR *>( pPresentModes ) ) );
+  }
+
+#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename PresentModeKHRAllocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
+    typename ResultValueType<std::vector<PresentModeKHR, PresentModeKHRAllocator>>::type
+    PhysicalDevice::getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
+                                                Dispatch const &                      d ) const
+  {
+    std::vector<PresentModeKHR, PresentModeKHRAllocator> presentModes;
+    uint32_t                                             presentModeCount;
+    Result                                               result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetPhysicalDeviceSurfacePresentModes2EXT(
+        m_physicalDevice,
+        reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
+        &presentModeCount,
+        nullptr ) );
+      if ( ( result == Result::eSuccess ) && presentModeCount )
+      {
+        presentModes.resize( presentModeCount );
+        result = static_cast<Result>( d.vkGetPhysicalDeviceSurfacePresentModes2EXT(
+          m_physicalDevice,
+          reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
+          &presentModeCount,
+          reinterpret_cast<VkPresentModeKHR *>( presentModes.data() ) ) );
+        VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( presentModeCount < presentModes.size() ) )
+    {
+      presentModes.resize( presentModeCount );
+    }
+    return createResultValue(
+      result, presentModes, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfacePresentModes2EXT" );
+  }
+
+  template <typename PresentModeKHRAllocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, PresentModeKHR>::value, int>::type>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
+    typename ResultValueType<std::vector<PresentModeKHR, PresentModeKHRAllocator>>::type
+    PhysicalDevice::getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
+                                                PresentModeKHRAllocator &             presentModeKHRAllocator,
+                                                Dispatch const &                      d ) const
+  {
+    std::vector<PresentModeKHR, PresentModeKHRAllocator> presentModes( presentModeKHRAllocator );
+    uint32_t                                             presentModeCount;
+    Result                                               result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetPhysicalDeviceSurfacePresentModes2EXT(
+        m_physicalDevice,
+        reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
+        &presentModeCount,
+        nullptr ) );
+      if ( ( result == Result::eSuccess ) && presentModeCount )
+      {
+        presentModes.resize( presentModeCount );
+        result = static_cast<Result>( d.vkGetPhysicalDeviceSurfacePresentModes2EXT(
+          m_physicalDevice,
+          reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
+          &presentModeCount,
+          reinterpret_cast<VkPresentModeKHR *>( presentModes.data() ) ) );
+        VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( presentModeCount < presentModes.size() ) )
+    {
+      presentModes.resize( presentModeCount );
+    }
+    return createResultValue(
+      result, presentModes, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfacePresentModes2EXT" );
+  }
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#  ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::acquireFullScreenExclusiveModeEXT(
+    VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkAcquireFullScreenExclusiveModeEXT( m_device, static_cast<VkSwapchainKHR>( swapchain ) ) );
+  }
+#  else
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
+    Device::acquireFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d ) const
+  {
+    Result result = static_cast<Result>(
+      d.vkAcquireFullScreenExclusiveModeEXT( m_device, static_cast<VkSwapchainKHR>( swapchain ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::acquireFullScreenExclusiveModeEXT" );
+  }
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#  ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::releaseFullScreenExclusiveModeEXT(
+    VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkReleaseFullScreenExclusiveModeEXT( m_device, static_cast<VkSwapchainKHR>( swapchain ) ) );
+  }
+#  else
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
+    Device::releaseFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d ) const
+  {
+    Result result = static_cast<Result>(
+      d.vkReleaseFullScreenExclusiveModeEXT( m_device, static_cast<VkSwapchainKHR>( swapchain ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::releaseFullScreenExclusiveModeEXT" );
+  }
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::getGroupSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
+                                             VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR *      pModes,
+                                             Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkGetDeviceGroupSurfacePresentModes2EXT(
+      m_device,
+      reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( pSurfaceInfo ),
+      reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR *>( pModes ) ) );
+  }
+
+#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR>::type
+    Device::getGroupSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
+                                             Dispatch const &                      d ) const
+  {
+    VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR modes;
+    Result result = static_cast<Result>( d.vkGetDeviceGroupSurfacePresentModes2EXT(
+      m_device,
+      reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
+      reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR *>( &modes ) ) );
+    return createResultValue( result, modes, VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupSurfacePresentModes2EXT" );
+  }
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VK_USE_PLATFORM_WIN32_KHR*/
+
+  //=== VK_EXT_headless_surface ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Instance::createHeadlessSurfaceEXT( const VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT * pCreateInfo,
+                                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks *          pAllocator,
+                                        VULKAN_HPP_NAMESPACE::SurfaceKHR *                         pSurface,
+                                        Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkCreateHeadlessSurfaceEXT( m_instance,
+                                    reinterpret_cast<const VkHeadlessSurfaceCreateInfoEXT *>( pCreateInfo ),
+                                    reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
+                                    reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
+    Instance::createHeadlessSurfaceEXT( const HeadlessSurfaceCreateInfoEXT & createInfo,
+                                        Optional<const AllocationCallbacks>  allocator,
+                                        Dispatch const &                     d ) const
+  {
+    VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
+    Result                           result = static_cast<Result>(
+      d.vkCreateHeadlessSurfaceEXT( m_instance,
+                                    reinterpret_cast<const VkHeadlessSurfaceCreateInfoEXT *>( &createInfo ),
+                                    reinterpret_cast<const VkAllocationCallbacks *>(
+                                      static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                    reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
+    return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createHeadlessSurfaceEXT" );
+  }
+
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
+    Instance::createHeadlessSurfaceEXTUnique( const HeadlessSurfaceCreateInfoEXT & createInfo,
+                                              Optional<const AllocationCallbacks>  allocator,
+                                              Dispatch const &                     d ) const
+  {
+    VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
+    Result                           result = static_cast<Result>(
+      d.vkCreateHeadlessSurfaceEXT( m_instance,
+                                    reinterpret_cast<const VkHeadlessSurfaceCreateInfoEXT *>( &createInfo ),
+                                    reinterpret_cast<const VkAllocationCallbacks *>(
+                                      static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                    reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
+    ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d );
+    return createResultValue<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>(
+      result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createHeadlessSurfaceEXTUnique", deleter );
+  }
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  //=== VK_KHR_buffer_device_address ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddressKHR(
+    const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<DeviceAddress>(
+      d.vkGetBufferDeviceAddressKHR( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo *>( pInfo ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddressKHR( const BufferDeviceAddressInfo & info,
+                                                               Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return d.vkGetBufferDeviceAddressKHR( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE uint64_t Device::getBufferOpaqueCaptureAddressKHR(
+    const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return d.vkGetBufferOpaqueCaptureAddressKHR( m_device,
+                                                 reinterpret_cast<const VkBufferDeviceAddressInfo *>( pInfo ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE uint64_t Device::getBufferOpaqueCaptureAddressKHR( const BufferDeviceAddressInfo & info,
+                                                                       Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return d.vkGetBufferOpaqueCaptureAddressKHR( m_device,
+                                                 reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE uint64_t
+    Device::getMemoryOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo * pInfo,
+                                              Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return d.vkGetDeviceMemoryOpaqueCaptureAddressKHR(
+      m_device, reinterpret_cast<const VkDeviceMemoryOpaqueCaptureAddressInfo *>( pInfo ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE uint64_t Device::getMemoryOpaqueCaptureAddressKHR(
+    const DeviceMemoryOpaqueCaptureAddressInfo & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return d.vkGetDeviceMemoryOpaqueCaptureAddressKHR(
+      m_device, reinterpret_cast<const VkDeviceMemoryOpaqueCaptureAddressInfo *>( &info ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  //=== VK_EXT_line_rasterization ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setLineStippleEXT( uint32_t         lineStippleFactor,
+                                                           uint16_t         lineStipplePattern,
+                                                           Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetLineStippleEXT( m_commandBuffer, lineStippleFactor, lineStipplePattern );
+  }
+
+  //=== VK_EXT_host_query_reset ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::resetQueryPoolEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
+                                                    uint32_t                        firstQuery,
+                                                    uint32_t                        queryCount,
+                                                    Dispatch const &                d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkResetQueryPoolEXT( m_device, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount );
+  }
+
+  //=== VK_EXT_extended_dynamic_state ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setCullModeEXT( VULKAN_HPP_NAMESPACE::CullModeFlags cullMode,
+                                                        Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetCullModeEXT( m_commandBuffer, static_cast<VkCullModeFlags>( cullMode ) );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setFrontFaceEXT( VULKAN_HPP_NAMESPACE::FrontFace frontFace,
+                                                         Dispatch const &                d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetFrontFaceEXT( m_commandBuffer, static_cast<VkFrontFace>( frontFace ) );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    CommandBuffer::setPrimitiveTopologyEXT( VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology,
+                                            Dispatch const &                        d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetPrimitiveTopologyEXT( m_commandBuffer, static_cast<VkPrimitiveTopology>( primitiveTopology ) );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setViewportWithCountEXT( uint32_t                               viewportCount,
+                                                                 const VULKAN_HPP_NAMESPACE::Viewport * pViewports,
+                                                                 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetViewportWithCountEXT(
+      m_commandBuffer, viewportCount, reinterpret_cast<const VkViewport *>( pViewports ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    CommandBuffer::setViewportWithCountEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports,
+                                            Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetViewportWithCountEXT(
+      m_commandBuffer, viewports.size(), reinterpret_cast<const VkViewport *>( viewports.data() ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setScissorWithCountEXT( uint32_t                             scissorCount,
+                                                                const VULKAN_HPP_NAMESPACE::Rect2D * pScissors,
+                                                                Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetScissorWithCountEXT( m_commandBuffer, scissorCount, reinterpret_cast<const VkRect2D *>( pScissors ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    CommandBuffer::setScissorWithCountEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors,
+                                           Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetScissorWithCountEXT(
+      m_commandBuffer, scissors.size(), reinterpret_cast<const VkRect2D *>( scissors.data() ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers2EXT( uint32_t                                 firstBinding,
+                                                               uint32_t                                 bindingCount,
+                                                               const VULKAN_HPP_NAMESPACE::Buffer *     pBuffers,
+                                                               const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets,
+                                                               const VULKAN_HPP_NAMESPACE::DeviceSize * pSizes,
+                                                               const VULKAN_HPP_NAMESPACE::DeviceSize * pStrides,
+                                                               Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdBindVertexBuffers2EXT( m_commandBuffer,
+                                  firstBinding,
+                                  bindingCount,
+                                  reinterpret_cast<const VkBuffer *>( pBuffers ),
+                                  reinterpret_cast<const VkDeviceSize *>( pOffsets ),
+                                  reinterpret_cast<const VkDeviceSize *>( pSizes ),
+                                  reinterpret_cast<const VkDeviceSize *>( pStrides ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    CommandBuffer::bindVertexBuffers2EXT( uint32_t                                                   firstBinding,
+                                          ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &     buffers,
+                                          ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,
+                                          ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes,
+                                          ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & strides,
+                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
+  {
+#  ifdef VULKAN_HPP_NO_EXCEPTIONS
+    VULKAN_HPP_ASSERT( buffers.size() == offsets.size() );
+    VULKAN_HPP_ASSERT( sizes.empty() || buffers.size() == sizes.size() );
+    VULKAN_HPP_ASSERT( strides.empty() || buffers.size() == strides.size() );
+#  else
+    if ( buffers.size() != offsets.size() )
+    {
+      throw LogicError( VULKAN_HPP_NAMESPACE_STRING
+                        "::CommandBuffer::bindVertexBuffers2EXT: buffers.size() != offsets.size()" );
+    }
+    if ( !sizes.empty() && buffers.size() != sizes.size() )
+    {
+      throw LogicError( VULKAN_HPP_NAMESPACE_STRING
+                        "::CommandBuffer::bindVertexBuffers2EXT: buffers.size() != sizes.size()" );
+    }
+    if ( !strides.empty() && buffers.size() != strides.size() )
+    {
+      throw LogicError( VULKAN_HPP_NAMESPACE_STRING
+                        "::CommandBuffer::bindVertexBuffers2EXT: buffers.size() != strides.size()" );
+    }
+#  endif /*VULKAN_HPP_NO_EXCEPTIONS*/
+
+    d.vkCmdBindVertexBuffers2EXT( m_commandBuffer,
+                                  firstBinding,
+                                  buffers.size(),
+                                  reinterpret_cast<const VkBuffer *>( buffers.data() ),
+                                  reinterpret_cast<const VkDeviceSize *>( offsets.data() ),
+                                  reinterpret_cast<const VkDeviceSize *>( sizes.data() ),
+                                  reinterpret_cast<const VkDeviceSize *>( strides.data() ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setDepthTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable,
+                                                               Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetDepthTestEnableEXT( m_commandBuffer, static_cast<VkBool32>( depthTestEnable ) );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setDepthWriteEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable,
+                                                                Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetDepthWriteEnableEXT( m_commandBuffer, static_cast<VkBool32>( depthWriteEnable ) );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setDepthCompareOpEXT( VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp,
+                                                              Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetDepthCompareOpEXT( m_commandBuffer, static_cast<VkCompareOp>( depthCompareOp ) );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setDepthBoundsTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable,
+                                                                     Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetDepthBoundsTestEnableEXT( m_commandBuffer, static_cast<VkBool32>( depthBoundsTestEnable ) );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setStencilTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable,
+                                                                 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetStencilTestEnableEXT( m_commandBuffer, static_cast<VkBool32>( stencilTestEnable ) );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setStencilOpEXT( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
+                                                         VULKAN_HPP_NAMESPACE::StencilOp        failOp,
+                                                         VULKAN_HPP_NAMESPACE::StencilOp        passOp,
+                                                         VULKAN_HPP_NAMESPACE::StencilOp        depthFailOp,
+                                                         VULKAN_HPP_NAMESPACE::CompareOp        compareOp,
+                                                         Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetStencilOpEXT( m_commandBuffer,
+                            static_cast<VkStencilFaceFlags>( faceMask ),
+                            static_cast<VkStencilOp>( failOp ),
+                            static_cast<VkStencilOp>( passOp ),
+                            static_cast<VkStencilOp>( depthFailOp ),
+                            static_cast<VkCompareOp>( compareOp ) );
+  }
+
+  //=== VK_KHR_deferred_host_operations ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::createDeferredOperationKHR( const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                        VULKAN_HPP_NAMESPACE::DeferredOperationKHR *      pDeferredOperation,
+                                        Dispatch const &                                  d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkCreateDeferredOperationKHR( m_device,
+                                      reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
+                                      reinterpret_cast<VkDeferredOperationKHR *>( pDeferredOperation ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::DeferredOperationKHR>::type
+    Device::createDeferredOperationKHR( Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
+  {
+    VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation;
+    Result                                     result = static_cast<Result>(
+      d.vkCreateDeferredOperationKHR( m_device,
+                                      reinterpret_cast<const VkAllocationCallbacks *>(
+                                        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                      reinterpret_cast<VkDeferredOperationKHR *>( &deferredOperation ) ) );
+    return createResultValue(
+      result, deferredOperation, VULKAN_HPP_NAMESPACE_STRING "::Device::createDeferredOperationKHR" );
+  }
+
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DeferredOperationKHR, Dispatch>>::type
+    Device::createDeferredOperationKHRUnique( Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
+  {
+    VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation;
+    Result                                     result = static_cast<Result>(
+      d.vkCreateDeferredOperationKHR( m_device,
+                                      reinterpret_cast<const VkAllocationCallbacks *>(
+                                        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                      reinterpret_cast<VkDeferredOperationKHR *>( &deferredOperation ) ) );
+    ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
+    return createResultValue<VULKAN_HPP_NAMESPACE::DeferredOperationKHR, Dispatch>(
+      result, deferredOperation, VULKAN_HPP_NAMESPACE_STRING "::Device::createDeferredOperationKHRUnique", deleter );
+  }
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    Device::destroyDeferredOperationKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR        operation,
+                                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                         Dispatch const &                                  d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyDeferredOperationKHR( m_device,
+                                     static_cast<VkDeferredOperationKHR>( operation ),
+                                     reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyDeferredOperationKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
+                                                              Optional<const AllocationCallbacks>        allocator,
+                                                              Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyDeferredOperationKHR( m_device,
+                                     static_cast<VkDeferredOperationKHR>( operation ),
+                                     reinterpret_cast<const VkAllocationCallbacks *>(
+                                       static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::DeferredOperationKHR        operation,
+                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyDeferredOperationKHR( m_device,
+                                     static_cast<VkDeferredOperationKHR>( operation ),
+                                     reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
+                                          Optional<const AllocationCallbacks>        allocator,
+                                          Dispatch const &                           d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyDeferredOperationKHR( m_device,
+                                     static_cast<VkDeferredOperationKHR>( operation ),
+                                     reinterpret_cast<const VkAllocationCallbacks *>(
+                                       static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE uint32_t Device::getDeferredOperationMaxConcurrencyKHR(
+    VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return d.vkGetDeferredOperationMaxConcurrencyKHR( m_device, static_cast<VkDeferredOperationKHR>( operation ) );
+  }
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getDeferredOperationResultKHR(
+    VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkGetDeferredOperationResultKHR( m_device, static_cast<VkDeferredOperationKHR>( operation ) ) );
+  }
+#else
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getDeferredOperationResultKHR(
+    VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, Dispatch const & d ) const
+  {
+    Result result = static_cast<Result>(
+      d.vkGetDeferredOperationResultKHR( m_device, static_cast<VkDeferredOperationKHR>( operation ) ) );
+    return createResultValue( result,
+                              VULKAN_HPP_NAMESPACE_STRING "::Device::getDeferredOperationResultKHR",
+                              { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eNotReady } );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::deferredOperationJoinKHR(
+    VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkDeferredOperationJoinKHR( m_device, static_cast<VkDeferredOperationKHR>( operation ) ) );
+  }
+#else
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::deferredOperationJoinKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, Dispatch const & d ) const
+  {
+    Result result =
+      static_cast<Result>( d.vkDeferredOperationJoinKHR( m_device, static_cast<VkDeferredOperationKHR>( operation ) ) );
+    return createResultValue( result,
+                              VULKAN_HPP_NAMESPACE_STRING "::Device::deferredOperationJoinKHR",
+                              { VULKAN_HPP_NAMESPACE::Result::eSuccess,
+                                VULKAN_HPP_NAMESPACE::Result::eThreadDoneKHR,
+                                VULKAN_HPP_NAMESPACE::Result::eThreadIdleKHR } );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  //=== VK_KHR_pipeline_executable_properties ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::getPipelineExecutablePropertiesKHR( const VULKAN_HPP_NAMESPACE::PipelineInfoKHR * pPipelineInfo,
+                                                uint32_t *                                    pExecutableCount,
+                                                VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR * pProperties,
+                                                Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkGetPipelineExecutablePropertiesKHR( m_device,
+                                              reinterpret_cast<const VkPipelineInfoKHR *>( pPipelineInfo ),
+                                              pExecutableCount,
+                                              reinterpret_cast<VkPipelineExecutablePropertiesKHR *>( pProperties ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename PipelineExecutablePropertiesKHRAllocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<
+    std::vector<PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator>>::type
+    Device::getPipelineExecutablePropertiesKHR( const PipelineInfoKHR & pipelineInfo, Dispatch const & d ) const
+  {
+    std::vector<PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator> properties;
+    uint32_t                                                                               executableCount;
+    Result                                                                                 result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetPipelineExecutablePropertiesKHR(
+        m_device, reinterpret_cast<const VkPipelineInfoKHR *>( &pipelineInfo ), &executableCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && executableCount )
+      {
+        properties.resize( executableCount );
+        result = static_cast<Result>( d.vkGetPipelineExecutablePropertiesKHR(
+          m_device,
+          reinterpret_cast<const VkPipelineInfoKHR *>( &pipelineInfo ),
+          &executableCount,
+          reinterpret_cast<VkPipelineExecutablePropertiesKHR *>( properties.data() ) ) );
+        VULKAN_HPP_ASSERT( executableCount <= properties.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( executableCount < properties.size() ) )
+    {
+      properties.resize( executableCount );
+    }
+    return createResultValue(
+      result, properties, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutablePropertiesKHR" );
+  }
+
+  template <
+    typename PipelineExecutablePropertiesKHRAllocator,
+    typename Dispatch,
+    typename B,
+    typename std::enable_if<std::is_same<typename B::value_type, PipelineExecutablePropertiesKHR>::value, int>::type>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<
+    std::vector<PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator>>::type
+    Device::getPipelineExecutablePropertiesKHR(
+      const PipelineInfoKHR &                    pipelineInfo,
+      PipelineExecutablePropertiesKHRAllocator & pipelineExecutablePropertiesKHRAllocator,
+      Dispatch const &                           d ) const
+  {
+    std::vector<PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator> properties(
+      pipelineExecutablePropertiesKHRAllocator );
+    uint32_t executableCount;
+    Result   result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetPipelineExecutablePropertiesKHR(
+        m_device, reinterpret_cast<const VkPipelineInfoKHR *>( &pipelineInfo ), &executableCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && executableCount )
+      {
+        properties.resize( executableCount );
+        result = static_cast<Result>( d.vkGetPipelineExecutablePropertiesKHR(
+          m_device,
+          reinterpret_cast<const VkPipelineInfoKHR *>( &pipelineInfo ),
+          &executableCount,
+          reinterpret_cast<VkPipelineExecutablePropertiesKHR *>( properties.data() ) ) );
+        VULKAN_HPP_ASSERT( executableCount <= properties.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( executableCount < properties.size() ) )
+    {
+      properties.resize( executableCount );
+    }
+    return createResultValue(
+      result, properties, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutablePropertiesKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::getPipelineExecutableStatisticsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR * pExecutableInfo,
+                                                uint32_t *                                              pStatisticCount,
+                                                VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR *  pStatistics,
+                                                Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkGetPipelineExecutableStatisticsKHR( m_device,
+                                              reinterpret_cast<const VkPipelineExecutableInfoKHR *>( pExecutableInfo ),
+                                              pStatisticCount,
+                                              reinterpret_cast<VkPipelineExecutableStatisticKHR *>( pStatistics ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename PipelineExecutableStatisticKHRAllocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
+    typename ResultValueType<std::vector<PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator>>::type
+    Device::getPipelineExecutableStatisticsKHR( const PipelineExecutableInfoKHR & executableInfo,
+                                                Dispatch const &                  d ) const
+  {
+    std::vector<PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator> statistics;
+    uint32_t                                                                             statisticCount;
+    Result                                                                               result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetPipelineExecutableStatisticsKHR(
+        m_device,
+        reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ),
+        &statisticCount,
+        nullptr ) );
+      if ( ( result == Result::eSuccess ) && statisticCount )
+      {
+        statistics.resize( statisticCount );
+        result = static_cast<Result>( d.vkGetPipelineExecutableStatisticsKHR(
+          m_device,
+          reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ),
+          &statisticCount,
+          reinterpret_cast<VkPipelineExecutableStatisticKHR *>( statistics.data() ) ) );
+        VULKAN_HPP_ASSERT( statisticCount <= statistics.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( statisticCount < statistics.size() ) )
+    {
+      statistics.resize( statisticCount );
+    }
+    return createResultValue(
+      result, statistics, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutableStatisticsKHR" );
+  }
+
+  template <
+    typename PipelineExecutableStatisticKHRAllocator,
+    typename Dispatch,
+    typename B,
+    typename std::enable_if<std::is_same<typename B::value_type, PipelineExecutableStatisticKHR>::value, int>::type>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
+    typename ResultValueType<std::vector<PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator>>::type
+    Device::getPipelineExecutableStatisticsKHR(
+      const PipelineExecutableInfoKHR &         executableInfo,
+      PipelineExecutableStatisticKHRAllocator & pipelineExecutableStatisticKHRAllocator,
+      Dispatch const &                          d ) const
+  {
+    std::vector<PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator> statistics(
+      pipelineExecutableStatisticKHRAllocator );
+    uint32_t statisticCount;
+    Result   result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetPipelineExecutableStatisticsKHR(
+        m_device,
+        reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ),
+        &statisticCount,
+        nullptr ) );
+      if ( ( result == Result::eSuccess ) && statisticCount )
+      {
+        statistics.resize( statisticCount );
+        result = static_cast<Result>( d.vkGetPipelineExecutableStatisticsKHR(
+          m_device,
+          reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ),
+          &statisticCount,
+          reinterpret_cast<VkPipelineExecutableStatisticKHR *>( statistics.data() ) ) );
+        VULKAN_HPP_ASSERT( statisticCount <= statistics.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( statisticCount < statistics.size() ) )
+    {
+      statistics.resize( statisticCount );
+    }
+    return createResultValue(
+      result, statistics, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutableStatisticsKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getPipelineExecutableInternalRepresentationsKHR(
+    const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR *             pExecutableInfo,
+    uint32_t *                                                          pInternalRepresentationCount,
+    VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR * pInternalRepresentations,
+    Dispatch const &                                                    d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkGetPipelineExecutableInternalRepresentationsKHR(
+      m_device,
+      reinterpret_cast<const VkPipelineExecutableInfoKHR *>( pExecutableInfo ),
+      pInternalRepresentationCount,
+      reinterpret_cast<VkPipelineExecutableInternalRepresentationKHR *>( pInternalRepresentations ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename PipelineExecutableInternalRepresentationKHRAllocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
+    typename ResultValueType<std::vector<PipelineExecutableInternalRepresentationKHR,
+                                         PipelineExecutableInternalRepresentationKHRAllocator>>::type
+    Device::getPipelineExecutableInternalRepresentationsKHR( const PipelineExecutableInfoKHR & executableInfo,
+                                                             Dispatch const &                  d ) const
+  {
+    std::vector<PipelineExecutableInternalRepresentationKHR, PipelineExecutableInternalRepresentationKHRAllocator>
+             internalRepresentations;
+    uint32_t internalRepresentationCount;
+    Result   result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetPipelineExecutableInternalRepresentationsKHR(
+        m_device,
+        reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ),
+        &internalRepresentationCount,
+        nullptr ) );
+      if ( ( result == Result::eSuccess ) && internalRepresentationCount )
+      {
+        internalRepresentations.resize( internalRepresentationCount );
+        result = static_cast<Result>( d.vkGetPipelineExecutableInternalRepresentationsKHR(
+          m_device,
+          reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ),
+          &internalRepresentationCount,
+          reinterpret_cast<VkPipelineExecutableInternalRepresentationKHR *>( internalRepresentations.data() ) ) );
+        VULKAN_HPP_ASSERT( internalRepresentationCount <= internalRepresentations.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( internalRepresentationCount < internalRepresentations.size() ) )
+    {
+      internalRepresentations.resize( internalRepresentationCount );
+    }
+    return createResultValue( result,
+                              internalRepresentations,
+                              VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutableInternalRepresentationsKHR" );
+  }
+
+  template <
+    typename PipelineExecutableInternalRepresentationKHRAllocator,
+    typename Dispatch,
+    typename B,
+    typename std::enable_if<std::is_same<typename B::value_type, PipelineExecutableInternalRepresentationKHR>::value,
+                            int>::type>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
+    typename ResultValueType<std::vector<PipelineExecutableInternalRepresentationKHR,
+                                         PipelineExecutableInternalRepresentationKHRAllocator>>::type
+    Device::getPipelineExecutableInternalRepresentationsKHR(
+      const PipelineExecutableInfoKHR &                      executableInfo,
+      PipelineExecutableInternalRepresentationKHRAllocator & pipelineExecutableInternalRepresentationKHRAllocator,
+      Dispatch const &                                       d ) const
+  {
+    std::vector<PipelineExecutableInternalRepresentationKHR, PipelineExecutableInternalRepresentationKHRAllocator>
+             internalRepresentations( pipelineExecutableInternalRepresentationKHRAllocator );
+    uint32_t internalRepresentationCount;
+    Result   result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetPipelineExecutableInternalRepresentationsKHR(
+        m_device,
+        reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ),
+        &internalRepresentationCount,
+        nullptr ) );
+      if ( ( result == Result::eSuccess ) && internalRepresentationCount )
+      {
+        internalRepresentations.resize( internalRepresentationCount );
+        result = static_cast<Result>( d.vkGetPipelineExecutableInternalRepresentationsKHR(
+          m_device,
+          reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ),
+          &internalRepresentationCount,
+          reinterpret_cast<VkPipelineExecutableInternalRepresentationKHR *>( internalRepresentations.data() ) ) );
+        VULKAN_HPP_ASSERT( internalRepresentationCount <= internalRepresentations.size() );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( ( result == Result::eSuccess ) && ( internalRepresentationCount < internalRepresentations.size() ) )
+    {
+      internalRepresentations.resize( internalRepresentationCount );
+    }
+    return createResultValue( result,
+                              internalRepresentations,
+                              VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutableInternalRepresentationsKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  //=== VK_NV_device_generated_commands ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::getGeneratedCommandsMemoryRequirementsNV(
+    const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV * pInfo,
+    VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                             pMemoryRequirements,
+    Dispatch const &                                                        d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkGetGeneratedCommandsMemoryRequirementsNV(
+      m_device,
+      reinterpret_cast<const VkGeneratedCommandsMemoryRequirementsInfoNV *>( pInfo ),
+      reinterpret_cast<VkMemoryRequirements2 *>( pMemoryRequirements ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2
+    Device::getGeneratedCommandsMemoryRequirementsNV( const GeneratedCommandsMemoryRequirementsInfoNV & info,
+                                                      Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements;
+    d.vkGetGeneratedCommandsMemoryRequirementsNV(
+      m_device,
+      reinterpret_cast<const VkGeneratedCommandsMemoryRequirementsInfoNV *>( &info ),
+      reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
+    return memoryRequirements;
+  }
+
+  template <typename X, typename Y, typename... Z, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
+    Device::getGeneratedCommandsMemoryRequirementsNV( const GeneratedCommandsMemoryRequirementsInfoNV & info,
+                                                      Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    StructureChain<X, Y, Z...>                  structureChain;
+    VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements =
+      structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>();
+    d.vkGetGeneratedCommandsMemoryRequirementsNV(
+      m_device,
+      reinterpret_cast<const VkGeneratedCommandsMemoryRequirementsInfoNV *>( &info ),
+      reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
+    return structureChain;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::preprocessGeneratedCommandsNV(
+    const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV * pGeneratedCommandsInfo,
+    Dispatch const &                                      d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdPreprocessGeneratedCommandsNV(
+      m_commandBuffer, reinterpret_cast<const VkGeneratedCommandsInfoNV *>( pGeneratedCommandsInfo ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    CommandBuffer::preprocessGeneratedCommandsNV( const GeneratedCommandsInfoNV & generatedCommandsInfo,
+                                                  Dispatch const &                d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdPreprocessGeneratedCommandsNV(
+      m_commandBuffer, reinterpret_cast<const VkGeneratedCommandsInfoNV *>( &generatedCommandsInfo ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::executeGeneratedCommandsNV(
+    VULKAN_HPP_NAMESPACE::Bool32                          isPreprocessed,
+    const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV * pGeneratedCommandsInfo,
+    Dispatch const &                                      d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdExecuteGeneratedCommandsNV( m_commandBuffer,
+                                       static_cast<VkBool32>( isPreprocessed ),
+                                       reinterpret_cast<const VkGeneratedCommandsInfoNV *>( pGeneratedCommandsInfo ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    CommandBuffer::executeGeneratedCommandsNV( VULKAN_HPP_NAMESPACE::Bool32    isPreprocessed,
+                                               const GeneratedCommandsInfoNV & generatedCommandsInfo,
+                                               Dispatch const &                d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdExecuteGeneratedCommandsNV( m_commandBuffer,
+                                       static_cast<VkBool32>( isPreprocessed ),
+                                       reinterpret_cast<const VkGeneratedCommandsInfoNV *>( &generatedCommandsInfo ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    CommandBuffer::bindPipelineShaderGroupNV( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
+                                              VULKAN_HPP_NAMESPACE::Pipeline          pipeline,
+                                              uint32_t                                groupIndex,
+                                              Dispatch const &                        d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdBindPipelineShaderGroupNV( m_commandBuffer,
+                                      static_cast<VkPipelineBindPoint>( pipelineBindPoint ),
+                                      static_cast<VkPipeline>( pipeline ),
+                                      groupIndex );
+  }
+
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createIndirectCommandsLayoutNV(
     const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV * pCreateInfo,
@@ -107039,112 +118569,56 @@ namespace VULKAN_HPP_NAMESPACE
 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::createPipelineCache( const VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo * pCreateInfo,
-                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks *     pAllocator,
-                                 VULKAN_HPP_NAMESPACE::PipelineCache *                 pPipelineCache,
-                                 Dispatch const &                                      d ) const VULKAN_HPP_NOEXCEPT
+  VULKAN_HPP_INLINE void
+    Device::destroyIndirectCommandsLayoutNV( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV    indirectCommandsLayout,
+                                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                             Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
-    return static_cast<Result>(
-      d.vkCreatePipelineCache( m_device,
-                               reinterpret_cast<const VkPipelineCacheCreateInfo *>( pCreateInfo ),
-                               reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
-                               reinterpret_cast<VkPipelineCache *>( pPipelineCache ) ) );
+    d.vkDestroyIndirectCommandsLayoutNV( m_device,
+                                         static_cast<VkIndirectCommandsLayoutNV>( indirectCommandsLayout ),
+                                         reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
 
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::PipelineCache>::type
-    Device::createPipelineCache( const PipelineCacheCreateInfo &     createInfo,
-                                 Optional<const AllocationCallbacks> allocator,
-                                 Dispatch const &                    d ) const
+  VULKAN_HPP_INLINE void
+    Device::destroyIndirectCommandsLayoutNV( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout,
+                                             Optional<const AllocationCallbacks>            allocator,
+                                             Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
-    VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache;
-    Result                              result = static_cast<Result>(
-      d.vkCreatePipelineCache( m_device,
-                               reinterpret_cast<const VkPipelineCacheCreateInfo *>( &createInfo ),
-                               reinterpret_cast<const VkAllocationCallbacks *>(
-                                 static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                               reinterpret_cast<VkPipelineCache *>( &pipelineCache ) ) );
-    return createResultValue( result, pipelineCache, VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineCache" );
+    d.vkDestroyIndirectCommandsLayoutNV(
+      m_device,
+      static_cast<VkIndirectCommandsLayoutNV>( indirectCommandsLayout ),
+      reinterpret_cast<const VkAllocationCallbacks *>(
+        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
   }
-
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineCache, Dispatch>>::type
-    Device::createPipelineCacheUnique( const PipelineCacheCreateInfo &     createInfo,
-                                       Optional<const AllocationCallbacks> allocator,
-                                       Dispatch const &                    d ) const
-  {
-    VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache;
-    Result                              result = static_cast<Result>(
-      d.vkCreatePipelineCache( m_device,
-                               reinterpret_cast<const VkPipelineCacheCreateInfo *>( &createInfo ),
-                               reinterpret_cast<const VkAllocationCallbacks *>(
-                                 static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                               reinterpret_cast<VkPipelineCache *>( &pipelineCache ) ) );
-    ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<VULKAN_HPP_NAMESPACE::PipelineCache, Dispatch>(
-      result, pipelineCache, VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineCacheUnique", deleter );
-  }
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::createPipelineLayout( const VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo * pCreateInfo,
-                                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks *      pAllocator,
-                                  VULKAN_HPP_NAMESPACE::PipelineLayout *                 pPipelineLayout,
-                                  Dispatch const &                                       d ) const VULKAN_HPP_NOEXCEPT
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV    indirectCommandsLayout,
+                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
-    return static_cast<Result>(
-      d.vkCreatePipelineLayout( m_device,
-                                reinterpret_cast<const VkPipelineLayoutCreateInfo *>( pCreateInfo ),
-                                reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
-                                reinterpret_cast<VkPipelineLayout *>( pPipelineLayout ) ) );
+    d.vkDestroyIndirectCommandsLayoutNV( m_device,
+                                         static_cast<VkIndirectCommandsLayoutNV>( indirectCommandsLayout ),
+                                         reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
 
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::PipelineLayout>::type
-    Device::createPipelineLayout( const PipelineLayoutCreateInfo &    createInfo,
-                                  Optional<const AllocationCallbacks> allocator,
-                                  Dispatch const &                    d ) const
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout,
+                                          Optional<const AllocationCallbacks>            allocator,
+                                          Dispatch const &                               d ) const VULKAN_HPP_NOEXCEPT
   {
-    VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout;
-    Result                               result = static_cast<Result>(
-      d.vkCreatePipelineLayout( m_device,
-                                reinterpret_cast<const VkPipelineLayoutCreateInfo *>( &createInfo ),
-                                reinterpret_cast<const VkAllocationCallbacks *>(
-                                  static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                reinterpret_cast<VkPipelineLayout *>( &pipelineLayout ) ) );
-    return createResultValue( result, pipelineLayout, VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineLayout" );
+    d.vkDestroyIndirectCommandsLayoutNV(
+      m_device,
+      static_cast<VkIndirectCommandsLayoutNV>( indirectCommandsLayout ),
+      reinterpret_cast<const VkAllocationCallbacks *>(
+        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
   }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineLayout, Dispatch>>::type
-    Device::createPipelineLayoutUnique( const PipelineLayoutCreateInfo &    createInfo,
-                                        Optional<const AllocationCallbacks> allocator,
-                                        Dispatch const &                    d ) const
-  {
-    VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout;
-    Result                               result = static_cast<Result>(
-      d.vkCreatePipelineLayout( m_device,
-                                reinterpret_cast<const VkPipelineLayoutCreateInfo *>( &createInfo ),
-                                reinterpret_cast<const VkAllocationCallbacks *>(
-                                  static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                reinterpret_cast<VkPipelineLayout *>( &pipelineLayout ) ) );
-    ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<VULKAN_HPP_NAMESPACE::PipelineLayout, Dispatch>(
-      result, pipelineLayout, VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineLayoutUnique", deleter );
-  }
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+  //=== VK_EXT_private_data ===
 
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
@@ -107200,57 +118674,615 @@ namespace VULKAN_HPP_NAMESPACE
 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::createQueryPool( const VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo * pCreateInfo,
-                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                             VULKAN_HPP_NAMESPACE::QueryPool *                 pQueryPool,
-                             Dispatch const &                                  d ) const VULKAN_HPP_NOEXCEPT
+  VULKAN_HPP_INLINE void
+    Device::destroyPrivateDataSlotEXT( VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT          privateDataSlot,
+                                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                       Dispatch const &                                  d ) const VULKAN_HPP_NOEXCEPT
   {
-    return static_cast<Result>( d.vkCreateQueryPool( m_device,
-                                                     reinterpret_cast<const VkQueryPoolCreateInfo *>( pCreateInfo ),
-                                                     reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
-                                                     reinterpret_cast<VkQueryPool *>( pQueryPool ) ) );
+    d.vkDestroyPrivateDataSlotEXT( m_device,
+                                   static_cast<VkPrivateDataSlotEXT>( privateDataSlot ),
+                                   reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
 
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::QueryPool>::type
-    Device::createQueryPool( const QueryPoolCreateInfo &         createInfo,
-                             Optional<const AllocationCallbacks> allocator,
-                             Dispatch const &                    d ) const
+  VULKAN_HPP_INLINE void Device::destroyPrivateDataSlotEXT( VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot,
+                                                            Optional<const AllocationCallbacks>      allocator,
+                                                            Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
-    VULKAN_HPP_NAMESPACE::QueryPool queryPool;
-    Result                          result = static_cast<Result>(
-      d.vkCreateQueryPool( m_device,
-                           reinterpret_cast<const VkQueryPoolCreateInfo *>( &createInfo ),
-                           reinterpret_cast<const VkAllocationCallbacks *>(
-                             static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                           reinterpret_cast<VkQueryPool *>( &queryPool ) ) );
-    return createResultValue( result, queryPool, VULKAN_HPP_NAMESPACE_STRING "::Device::createQueryPool" );
+    d.vkDestroyPrivateDataSlotEXT( m_device,
+                                   static_cast<VkPrivateDataSlotEXT>( privateDataSlot ),
+                                   reinterpret_cast<const VkAllocationCallbacks *>(
+                                     static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT          privateDataSlot,
+                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyPrivateDataSlotEXT( m_device,
+                                   static_cast<VkPrivateDataSlotEXT>( privateDataSlot ),
+                                   reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
   }
 
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot,
+                                          Optional<const AllocationCallbacks>      allocator,
+                                          Dispatch const &                         d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyPrivateDataSlotEXT( m_device,
+                                   static_cast<VkPrivateDataSlotEXT>( privateDataSlot ),
+                                   reinterpret_cast<const VkAllocationCallbacks *>(
+                                     static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType         objectType,
+                               uint64_t                                 objectHandle,
+                               VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot,
+                               uint64_t                                 data,
+                               Dispatch const &                         d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkSetPrivateDataEXT( m_device,
+                                                       static_cast<VkObjectType>( objectType ),
+                                                       objectHandle,
+                                                       static_cast<VkPrivateDataSlotEXT>( privateDataSlot ),
+                                                       data ) );
+  }
+#else
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<void>::type
+    Device::setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType objectType,
+                               uint64_t objectHandle,
+                               VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot,
+                               uint64_t data,
+                               Dispatch const & d ) const
+  {
+    Result result = static_cast<Result>( d.vkSetPrivateDataEXT( m_device,
+                                                                static_cast<VkObjectType>( objectType ),
+                                                                objectHandle,
+                                                                static_cast<VkPrivateDataSlotEXT>( privateDataSlot ),
+                                                                data ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setPrivateDataEXT" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::getPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType         objectType,
+                                                    uint64_t                                 objectHandle,
+                                                    VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot,
+                                                    uint64_t *                               pData,
+                                                    Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkGetPrivateDataEXT( m_device,
+                           static_cast<VkObjectType>( objectType ),
+                           objectHandle,
+                           static_cast<VkPrivateDataSlotEXT>( privateDataSlot ),
+                           pData );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t
+    Device::getPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType         objectType,
+                               uint64_t                                 objectHandle,
+                               VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot,
+                               Dispatch const &                         d ) const VULKAN_HPP_NOEXCEPT
+  {
+    uint64_t data;
+    d.vkGetPrivateDataEXT( m_device,
+                           static_cast<VkObjectType>( objectType ),
+                           objectHandle,
+                           static_cast<VkPrivateDataSlotEXT>( privateDataSlot ),
+                           &data );
+    return data;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#if defined( VK_ENABLE_BETA_EXTENSIONS )
+  //=== VK_KHR_video_encode_queue ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::encodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR * pEncodeInfo,
+                                                        Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdEncodeVideoKHR( m_commandBuffer, reinterpret_cast<const VkVideoEncodeInfoKHR *>( pEncodeInfo ) );
+  }
+
+#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::encodeVideoKHR( const VideoEncodeInfoKHR & encodeInfo,
+                                                        Dispatch const &           d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdEncodeVideoKHR( m_commandBuffer, reinterpret_cast<const VkVideoEncodeInfoKHR *>( &encodeInfo ) );
+  }
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VK_ENABLE_BETA_EXTENSIONS*/
+
+  //=== VK_KHR_synchronization2 ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setEvent2KHR( VULKAN_HPP_NAMESPACE::Event                     event,
+                                                      const VULKAN_HPP_NAMESPACE::DependencyInfoKHR * pDependencyInfo,
+                                                      Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetEvent2KHR( m_commandBuffer,
+                         static_cast<VkEvent>( event ),
+                         reinterpret_cast<const VkDependencyInfoKHR *>( pDependencyInfo ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setEvent2KHR( VULKAN_HPP_NAMESPACE::Event event,
+                                                      const DependencyInfoKHR &   dependencyInfo,
+                                                      Dispatch const &            d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetEvent2KHR( m_commandBuffer,
+                         static_cast<VkEvent>( event ),
+                         reinterpret_cast<const VkDependencyInfoKHR *>( &dependencyInfo ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::resetEvent2KHR( VULKAN_HPP_NAMESPACE::Event                  event,
+                                                        VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR stageMask,
+                                                        Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdResetEvent2KHR(
+      m_commandBuffer, static_cast<VkEvent>( event ), static_cast<VkPipelineStageFlags2KHR>( stageMask ) );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    CommandBuffer::waitEvents2KHR( uint32_t                                        eventCount,
+                                   const VULKAN_HPP_NAMESPACE::Event *             pEvents,
+                                   const VULKAN_HPP_NAMESPACE::DependencyInfoKHR * pDependencyInfos,
+                                   Dispatch const &                                d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdWaitEvents2KHR( m_commandBuffer,
+                           eventCount,
+                           reinterpret_cast<const VkEvent *>( pEvents ),
+                           reinterpret_cast<const VkDependencyInfoKHR *>( pDependencyInfos ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    CommandBuffer::waitEvents2KHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const &             events,
+                                   ArrayProxy<const VULKAN_HPP_NAMESPACE::DependencyInfoKHR> const & dependencyInfos,
+                                   Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
+  {
+#  ifdef VULKAN_HPP_NO_EXCEPTIONS
+    VULKAN_HPP_ASSERT( events.size() == dependencyInfos.size() );
+#  else
+    if ( events.size() != dependencyInfos.size() )
+    {
+      throw LogicError( VULKAN_HPP_NAMESPACE_STRING
+                        "::CommandBuffer::waitEvents2KHR: events.size() != dependencyInfos.size()" );
+    }
+#  endif /*VULKAN_HPP_NO_EXCEPTIONS*/
+
+    d.vkCmdWaitEvents2KHR( m_commandBuffer,
+                           events.size(),
+                           reinterpret_cast<const VkEvent *>( events.data() ),
+                           reinterpret_cast<const VkDependencyInfoKHR *>( dependencyInfos.data() ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    CommandBuffer::pipelineBarrier2KHR( const VULKAN_HPP_NAMESPACE::DependencyInfoKHR * pDependencyInfo,
+                                        Dispatch const &                                d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdPipelineBarrier2KHR( m_commandBuffer, reinterpret_cast<const VkDependencyInfoKHR *>( pDependencyInfo ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier2KHR( const DependencyInfoKHR & dependencyInfo,
+                                                             Dispatch const &          d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdPipelineBarrier2KHR( m_commandBuffer, reinterpret_cast<const VkDependencyInfoKHR *>( &dependencyInfo ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::writeTimestamp2KHR( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR stage,
+                                                            VULKAN_HPP_NAMESPACE::QueryPool              queryPool,
+                                                            uint32_t                                     query,
+                                                            Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdWriteTimestamp2KHR(
+      m_commandBuffer, static_cast<VkPipelineStageFlags2KHR>( stage ), static_cast<VkQueryPool>( queryPool ), query );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Queue::submit2KHR( uint32_t                                     submitCount,
+                       const VULKAN_HPP_NAMESPACE::SubmitInfo2KHR * pSubmits,
+                       VULKAN_HPP_NAMESPACE::Fence                  fence,
+                       Dispatch const &                             d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkQueueSubmit2KHR(
+      m_queue, submitCount, reinterpret_cast<const VkSubmitInfo2KHR *>( pSubmits ), static_cast<VkFence>( fence ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
+    Queue::submit2KHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo2KHR> const & submits,
+                       VULKAN_HPP_NAMESPACE::Fence                                    fence,
+                       Dispatch const &                                               d ) const
+  {
+    Result result =
+      static_cast<Result>( d.vkQueueSubmit2KHR( m_queue,
+                                                submits.size(),
+                                                reinterpret_cast<const VkSubmitInfo2KHR *>( submits.data() ),
+                                                static_cast<VkFence>( fence ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::submit2KHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::writeBufferMarker2AMD( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR stage,
+                                                               VULKAN_HPP_NAMESPACE::Buffer                 dstBuffer,
+                                                               VULKAN_HPP_NAMESPACE::DeviceSize             dstOffset,
+                                                               uint32_t                                     marker,
+                                                               Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdWriteBufferMarker2AMD( m_commandBuffer,
+                                  static_cast<VkPipelineStageFlags2KHR>( stage ),
+                                  static_cast<VkBuffer>( dstBuffer ),
+                                  static_cast<VkDeviceSize>( dstOffset ),
+                                  marker );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Queue::getCheckpointData2NV( uint32_t *                                pCheckpointDataCount,
+                                                      VULKAN_HPP_NAMESPACE::CheckpointData2NV * pCheckpointData,
+                                                      Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkGetQueueCheckpointData2NV(
+      m_queue, pCheckpointDataCount, reinterpret_cast<VkCheckpointData2NV *>( pCheckpointData ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename CheckpointData2NVAllocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<CheckpointData2NV, CheckpointData2NVAllocator>
+                                         Queue::getCheckpointData2NV( Dispatch const & d ) const
+  {
+    std::vector<CheckpointData2NV, CheckpointData2NVAllocator> checkpointData;
+    uint32_t                                                   checkpointDataCount;
+    d.vkGetQueueCheckpointData2NV( m_queue, &checkpointDataCount, nullptr );
+    checkpointData.resize( checkpointDataCount );
+    d.vkGetQueueCheckpointData2NV(
+      m_queue, &checkpointDataCount, reinterpret_cast<VkCheckpointData2NV *>( checkpointData.data() ) );
+    VULKAN_HPP_ASSERT( checkpointDataCount <= checkpointData.size() );
+    return checkpointData;
+  }
+
+  template <typename CheckpointData2NVAllocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, CheckpointData2NV>::value, int>::type>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<CheckpointData2NV, CheckpointData2NVAllocator>
+    Queue::getCheckpointData2NV( CheckpointData2NVAllocator & checkpointData2NVAllocator, Dispatch const & d ) const
+  {
+    std::vector<CheckpointData2NV, CheckpointData2NVAllocator> checkpointData( checkpointData2NVAllocator );
+    uint32_t                                                   checkpointDataCount;
+    d.vkGetQueueCheckpointData2NV( m_queue, &checkpointDataCount, nullptr );
+    checkpointData.resize( checkpointDataCount );
+    d.vkGetQueueCheckpointData2NV(
+      m_queue, &checkpointDataCount, reinterpret_cast<VkCheckpointData2NV *>( checkpointData.data() ) );
+    VULKAN_HPP_ASSERT( checkpointDataCount <= checkpointData.size() );
+    return checkpointData;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  //=== VK_NV_fragment_shading_rate_enums ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setFragmentShadingRateEnumNV(
+    VULKAN_HPP_NAMESPACE::FragmentShadingRateNV                  shadingRate,
+    const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2],
+    Dispatch const &                                             d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetFragmentShadingRateEnumNV( m_commandBuffer,
+                                         static_cast<VkFragmentShadingRateNV>( shadingRate ),
+                                         reinterpret_cast<const VkFragmentShadingRateCombinerOpKHR *>( combinerOps ) );
+  }
+
+  //=== VK_KHR_copy_commands2 ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    CommandBuffer::copyBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2KHR * pCopyBufferInfo,
+                                   Dispatch const &                                 d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdCopyBuffer2KHR( m_commandBuffer, reinterpret_cast<const VkCopyBufferInfo2KHR *>( pCopyBufferInfo ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::copyBuffer2KHR( const CopyBufferInfo2KHR & copyBufferInfo,
+                                                        Dispatch const &           d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdCopyBuffer2KHR( m_commandBuffer, reinterpret_cast<const VkCopyBufferInfo2KHR *>( &copyBufferInfo ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::copyImage2KHR( const VULKAN_HPP_NAMESPACE::CopyImageInfo2KHR * pCopyImageInfo,
+                                                       Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdCopyImage2KHR( m_commandBuffer, reinterpret_cast<const VkCopyImageInfo2KHR *>( pCopyImageInfo ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::copyImage2KHR( const CopyImageInfo2KHR & copyImageInfo,
+                                                       Dispatch const &          d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdCopyImage2KHR( m_commandBuffer, reinterpret_cast<const VkCopyImageInfo2KHR *>( &copyImageInfo ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage2KHR(
+    const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2KHR * pCopyBufferToImageInfo,
+    Dispatch const &                                        d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdCopyBufferToImage2KHR( m_commandBuffer,
+                                  reinterpret_cast<const VkCopyBufferToImageInfo2KHR *>( pCopyBufferToImageInfo ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage2KHR( const CopyBufferToImageInfo2KHR & copyBufferToImageInfo,
+                                                               Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdCopyBufferToImage2KHR( m_commandBuffer,
+                                  reinterpret_cast<const VkCopyBufferToImageInfo2KHR *>( &copyBufferToImageInfo ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer2KHR(
+    const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2KHR * pCopyImageToBufferInfo,
+    Dispatch const &                                        d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdCopyImageToBuffer2KHR( m_commandBuffer,
+                                  reinterpret_cast<const VkCopyImageToBufferInfo2KHR *>( pCopyImageToBufferInfo ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer2KHR( const CopyImageToBufferInfo2KHR & copyImageToBufferInfo,
+                                                               Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdCopyImageToBuffer2KHR( m_commandBuffer,
+                                  reinterpret_cast<const VkCopyImageToBufferInfo2KHR *>( &copyImageToBufferInfo ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::blitImage2KHR( const VULKAN_HPP_NAMESPACE::BlitImageInfo2KHR * pBlitImageInfo,
+                                                       Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdBlitImage2KHR( m_commandBuffer, reinterpret_cast<const VkBlitImageInfo2KHR *>( pBlitImageInfo ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::blitImage2KHR( const BlitImageInfo2KHR & blitImageInfo,
+                                                       Dispatch const &          d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdBlitImage2KHR( m_commandBuffer, reinterpret_cast<const VkBlitImageInfo2KHR *>( &blitImageInfo ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    CommandBuffer::resolveImage2KHR( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2KHR * pResolveImageInfo,
+                                     Dispatch const &                                   d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdResolveImage2KHR( m_commandBuffer, reinterpret_cast<const VkResolveImageInfo2KHR *>( pResolveImageInfo ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::resolveImage2KHR( const ResolveImageInfo2KHR & resolveImageInfo,
+                                                          Dispatch const &             d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdResolveImage2KHR( m_commandBuffer, reinterpret_cast<const VkResolveImageInfo2KHR *>( &resolveImageInfo ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#if defined( VK_USE_PLATFORM_WIN32_KHR )
+  //=== VK_NV_acquire_winrt_display ===
+
+#  ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::acquireWinrtDisplayNV(
+    VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkAcquireWinrtDisplayNV( m_physicalDevice, static_cast<VkDisplayKHR>( display ) ) );
+  }
+#  else
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
+    PhysicalDevice::acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d ) const
+  {
+    Result result =
+      static_cast<Result>( d.vkAcquireWinrtDisplayNV( m_physicalDevice, static_cast<VkDisplayKHR>( display ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::acquireWinrtDisplayNV" );
+  }
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    PhysicalDevice::getWinrtDisplayNV( uint32_t                           deviceRelativeId,
+                                       VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplay,
+                                       Dispatch const &                   d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkGetWinrtDisplayNV( m_physicalDevice, deviceRelativeId, reinterpret_cast<VkDisplayKHR *>( pDisplay ) ) );
+  }
+
+#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::QueryPool, Dispatch>>::type
-    Device::createQueryPoolUnique( const QueryPoolCreateInfo &         createInfo,
-                                   Optional<const AllocationCallbacks> allocator,
-                                   Dispatch const &                    d ) const
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type
+    PhysicalDevice::getWinrtDisplayNV( uint32_t deviceRelativeId, Dispatch const & d ) const
   {
-    VULKAN_HPP_NAMESPACE::QueryPool queryPool;
-    Result                          result = static_cast<Result>(
-      d.vkCreateQueryPool( m_device,
-                           reinterpret_cast<const VkQueryPoolCreateInfo *>( &createInfo ),
-                           reinterpret_cast<const VkAllocationCallbacks *>(
-                             static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                           reinterpret_cast<VkQueryPool *>( &queryPool ) ) );
-    ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<VULKAN_HPP_NAMESPACE::QueryPool, Dispatch>(
-      result, queryPool, VULKAN_HPP_NAMESPACE_STRING "::Device::createQueryPoolUnique", deleter );
+    VULKAN_HPP_NAMESPACE::DisplayKHR display;
+    Result                           result = static_cast<Result>(
+      d.vkGetWinrtDisplayNV( m_physicalDevice, deviceRelativeId, reinterpret_cast<VkDisplayKHR *>( &display ) ) );
+    return createResultValue( result, display, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getWinrtDisplayNV" );
   }
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#    ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type
+    PhysicalDevice::getWinrtDisplayNVUnique( uint32_t deviceRelativeId, Dispatch const & d ) const
+  {
+    VULKAN_HPP_NAMESPACE::DisplayKHR display;
+    Result                           result = static_cast<Result>(
+      d.vkGetWinrtDisplayNV( m_physicalDevice, deviceRelativeId, reinterpret_cast<VkDisplayKHR *>( &display ) ) );
+    ObjectRelease<PhysicalDevice, Dispatch> deleter( *this, d );
+    return createResultValue<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>(
+      result, display, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getWinrtDisplayNVUnique", deleter );
+  }
+#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif     /*VK_USE_PLATFORM_WIN32_KHR*/
+
+#if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
+  //=== VK_EXT_directfb_surface ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Instance::createDirectFBSurfaceEXT( const VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT * pCreateInfo,
+                                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks *          pAllocator,
+                                        VULKAN_HPP_NAMESPACE::SurfaceKHR *                         pSurface,
+                                        Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkCreateDirectFBSurfaceEXT( m_instance,
+                                    reinterpret_cast<const VkDirectFBSurfaceCreateInfoEXT *>( pCreateInfo ),
+                                    reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
+                                    reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
+  }
+
+#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
+    Instance::createDirectFBSurfaceEXT( const DirectFBSurfaceCreateInfoEXT & createInfo,
+                                        Optional<const AllocationCallbacks>  allocator,
+                                        Dispatch const &                     d ) const
+  {
+    VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
+    Result                           result = static_cast<Result>(
+      d.vkCreateDirectFBSurfaceEXT( m_instance,
+                                    reinterpret_cast<const VkDirectFBSurfaceCreateInfoEXT *>( &createInfo ),
+                                    reinterpret_cast<const VkAllocationCallbacks *>(
+                                      static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                    reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
+    return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDirectFBSurfaceEXT" );
+  }
+
+#    ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
+    Instance::createDirectFBSurfaceEXTUnique( const DirectFBSurfaceCreateInfoEXT & createInfo,
+                                              Optional<const AllocationCallbacks>  allocator,
+                                              Dispatch const &                     d ) const
+  {
+    VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
+    Result                           result = static_cast<Result>(
+      d.vkCreateDirectFBSurfaceEXT( m_instance,
+                                    reinterpret_cast<const VkDirectFBSurfaceCreateInfoEXT *>( &createInfo ),
+                                    reinterpret_cast<const VkAllocationCallbacks *>(
+                                      static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                    reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
+    ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d );
+    return createResultValue<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>(
+      result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDirectFBSurfaceEXTUnique", deleter );
+  }
+#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE Bool32 PhysicalDevice::getDirectFBPresentationSupportEXT(
+    uint32_t queueFamilyIndex, IDirectFB * dfb, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Bool32>(
+      d.vkGetPhysicalDeviceDirectFBPresentationSupportEXT( m_physicalDevice, queueFamilyIndex, dfb ) );
+  }
+
+#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE Bool32 PhysicalDevice::getDirectFBPresentationSupportEXT(
+    uint32_t queueFamilyIndex, IDirectFB & dfb, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return d.vkGetPhysicalDeviceDirectFBPresentationSupportEXT( m_physicalDevice, queueFamilyIndex, &dfb );
+  }
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VK_USE_PLATFORM_DIRECTFB_EXT*/
+
+  //=== VK_KHR_ray_tracing_pipeline ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::traceRaysKHR(
+    const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pRaygenShaderBindingTable,
+    const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pMissShaderBindingTable,
+    const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pHitShaderBindingTable,
+    const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pCallableShaderBindingTable,
+    uint32_t                                                    width,
+    uint32_t                                                    height,
+    uint32_t                                                    depth,
+    Dispatch const &                                            d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdTraceRaysKHR( m_commandBuffer,
+                         reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( pRaygenShaderBindingTable ),
+                         reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( pMissShaderBindingTable ),
+                         reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( pHitShaderBindingTable ),
+                         reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( pCallableShaderBindingTable ),
+                         width,
+                         height,
+                         depth );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::traceRaysKHR( const StridedDeviceAddressRegionKHR & raygenShaderBindingTable,
+                                                      const StridedDeviceAddressRegionKHR & missShaderBindingTable,
+                                                      const StridedDeviceAddressRegionKHR & hitShaderBindingTable,
+                                                      const StridedDeviceAddressRegionKHR & callableShaderBindingTable,
+                                                      uint32_t                              width,
+                                                      uint32_t                              height,
+                                                      uint32_t                              depth,
+                                                      Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdTraceRaysKHR( m_commandBuffer,
+                         reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &raygenShaderBindingTable ),
+                         reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &missShaderBindingTable ),
+                         reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &hitShaderBindingTable ),
+                         reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &callableShaderBindingTable ),
+                         width,
+                         height,
+                         depth );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
@@ -107482,5065 +119514,74 @@ namespace VULKAN_HPP_NAMESPACE
 
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::createRayTracingPipelinesNV( VULKAN_HPP_NAMESPACE::PipelineCache                          pipelineCache,
-                                         uint32_t                                                     createInfoCount,
-                                         const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV * pCreateInfos,
-                                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks *            pAllocator,
-                                         VULKAN_HPP_NAMESPACE::Pipeline *                             pPipelines,
-                                         Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkCreateRayTracingPipelinesNV( m_device,
-                                       static_cast<VkPipelineCache>( pipelineCache ),
-                                       createInfoCount,
-                                       reinterpret_cast<const VkRayTracingPipelineCreateInfoNV *>( pCreateInfos ),
-                                       reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
-                                       reinterpret_cast<VkPipeline *>( pPipelines ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename PipelineAllocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<Pipeline, PipelineAllocator>>
-                                         Device::createRayTracingPipelinesNV(
-      VULKAN_HPP_NAMESPACE::PipelineCache                                            pipelineCache,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
-      Optional<const AllocationCallbacks>                                            allocator,
-      Dispatch const &                                                               d ) const
-  {
-    std::vector<Pipeline, PipelineAllocator> pipelines( createInfos.size() );
-    Result                                   result = static_cast<Result>(
-      d.vkCreateRayTracingPipelinesNV( m_device,
-                                       static_cast<VkPipelineCache>( pipelineCache ),
-                                       createInfos.size(),
-                                       reinterpret_cast<const VkRayTracingPipelineCreateInfoNV *>( createInfos.data() ),
-                                       reinterpret_cast<const VkAllocationCallbacks *>(
-                                         static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                       reinterpret_cast<VkPipeline *>( pipelines.data() ) ) );
-    return createResultValue(
-      result,
-      pipelines,
-      VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNV",
-      { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
-  }
-
-  template <typename PipelineAllocator,
-            typename Dispatch,
-            typename B,
-            typename std::enable_if<std::is_same<typename B::value_type, Pipeline>::value, int>::type>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<Pipeline, PipelineAllocator>>
-                                         Device::createRayTracingPipelinesNV(
-      VULKAN_HPP_NAMESPACE::PipelineCache                                            pipelineCache,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
-      Optional<const AllocationCallbacks>                                            allocator,
-      PipelineAllocator &                                                            pipelineAllocator,
-      Dispatch const &                                                               d ) const
-  {
-    std::vector<Pipeline, PipelineAllocator> pipelines( createInfos.size(), pipelineAllocator );
-    Result                                   result = static_cast<Result>(
-      d.vkCreateRayTracingPipelinesNV( m_device,
-                                       static_cast<VkPipelineCache>( pipelineCache ),
-                                       createInfos.size(),
-                                       reinterpret_cast<const VkRayTracingPipelineCreateInfoNV *>( createInfos.data() ),
-                                       reinterpret_cast<const VkAllocationCallbacks *>(
-                                         static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                       reinterpret_cast<VkPipeline *>( pipelines.data() ) ) );
-    return createResultValue(
-      result,
-      pipelines,
-      VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNV",
-      { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<Pipeline>
-    Device::createRayTracingPipelineNV( VULKAN_HPP_NAMESPACE::PipelineCache                          pipelineCache,
-                                        const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV & createInfo,
-                                        Optional<const AllocationCallbacks>                          allocator,
-                                        Dispatch const &                                             d ) const
-  {
-    Pipeline pipeline;
-    Result   result = static_cast<Result>(
-      d.vkCreateRayTracingPipelinesNV( m_device,
-                                       static_cast<VkPipelineCache>( pipelineCache ),
-                                       1,
-                                       reinterpret_cast<const VkRayTracingPipelineCreateInfoNV *>( &createInfo ),
-                                       reinterpret_cast<const VkAllocationCallbacks *>(
-                                         static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                       reinterpret_cast<VkPipeline *>( &pipeline ) ) );
-    return createResultValue(
-      result,
-      pipeline,
-      VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelineNV",
-      { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
-  }
-
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Dispatch, typename PipelineAllocator>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
-                                         Device::createRayTracingPipelinesNVUnique(
-      VULKAN_HPP_NAMESPACE::PipelineCache                                            pipelineCache,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
-      Optional<const AllocationCallbacks>                                            allocator,
-      Dispatch const &                                                               d ) const
-  {
-    std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator> uniquePipelines;
-    std::vector<Pipeline>                                            pipelines( createInfos.size() );
-    Result                                                           result = static_cast<Result>(
-      d.vkCreateRayTracingPipelinesNV( m_device,
-                                       static_cast<VkPipelineCache>( pipelineCache ),
-                                       createInfos.size(),
-                                       reinterpret_cast<const VkRayTracingPipelineCreateInfoNV *>( createInfos.data() ),
-                                       reinterpret_cast<const VkAllocationCallbacks *>(
-                                         static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                       reinterpret_cast<VkPipeline *>( pipelines.data() ) ) );
-    if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) ||
-         ( result == VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) )
-    {
-      uniquePipelines.reserve( createInfos.size() );
-      ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-      for ( size_t i = 0; i < createInfos.size(); i++ )
-      {
-        uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipelines[i], deleter ) );
-      }
-    }
-    return createResultValue(
-      result,
-      std::move( uniquePipelines ),
-      VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNVUnique",
-      { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
-  }
-
-  template <
-    typename Dispatch,
-    typename PipelineAllocator,
-    typename B,
-    typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
-                                         Device::createRayTracingPipelinesNVUnique(
-      VULKAN_HPP_NAMESPACE::PipelineCache                                            pipelineCache,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
-      Optional<const AllocationCallbacks>                                            allocator,
-      PipelineAllocator &                                                            pipelineAllocator,
-      Dispatch const &                                                               d ) const
-  {
-    std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator> uniquePipelines( pipelineAllocator );
-    std::vector<Pipeline>                                            pipelines( createInfos.size() );
-    Result                                                           result = static_cast<Result>(
-      d.vkCreateRayTracingPipelinesNV( m_device,
-                                       static_cast<VkPipelineCache>( pipelineCache ),
-                                       createInfos.size(),
-                                       reinterpret_cast<const VkRayTracingPipelineCreateInfoNV *>( createInfos.data() ),
-                                       reinterpret_cast<const VkAllocationCallbacks *>(
-                                         static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                       reinterpret_cast<VkPipeline *>( pipelines.data() ) ) );
-    if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) ||
-         ( result == VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) )
-    {
-      uniquePipelines.reserve( createInfos.size() );
-      ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-      for ( size_t i = 0; i < createInfos.size(); i++ )
-      {
-        uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipelines[i], deleter ) );
-      }
-    }
-    return createResultValue(
-      result,
-      std::move( uniquePipelines ),
-      VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNVUnique",
-      { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<UniqueHandle<Pipeline, Dispatch>>
-    Device::createRayTracingPipelineNVUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
-                                              const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV & createInfo,
-                                              Optional<const AllocationCallbacks>                          allocator,
-                                              Dispatch const &                                             d ) const
-  {
-    Pipeline pipeline;
-    Result   result = static_cast<Result>(
-      d.vkCreateRayTracingPipelinesNV( m_device,
-                                       static_cast<VkPipelineCache>( pipelineCache ),
-                                       1,
-                                       reinterpret_cast<const VkRayTracingPipelineCreateInfoNV *>( &createInfo ),
-                                       reinterpret_cast<const VkAllocationCallbacks *>(
-                                         static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                       reinterpret_cast<VkPipeline *>( &pipeline ) ) );
-    ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<Pipeline, Dispatch>(
-      result,
-      pipeline,
-      VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelineNVUnique",
-      { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT },
-      deleter );
-  }
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::createRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo * pCreateInfo,
-                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks *  pAllocator,
-                              VULKAN_HPP_NAMESPACE::RenderPass *                 pRenderPass,
-                              Dispatch const &                                   d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkCreateRenderPass( m_device,
-                                                      reinterpret_cast<const VkRenderPassCreateInfo *>( pCreateInfo ),
-                                                      reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
-                                                      reinterpret_cast<VkRenderPass *>( pRenderPass ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::RenderPass>::type
-    Device::createRenderPass( const RenderPassCreateInfo &        createInfo,
-                              Optional<const AllocationCallbacks> allocator,
-                              Dispatch const &                    d ) const
-  {
-    VULKAN_HPP_NAMESPACE::RenderPass renderPass;
-    Result                           result = static_cast<Result>(
-      d.vkCreateRenderPass( m_device,
-                            reinterpret_cast<const VkRenderPassCreateInfo *>( &createInfo ),
-                            reinterpret_cast<const VkAllocationCallbacks *>(
-                              static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                            reinterpret_cast<VkRenderPass *>( &renderPass ) ) );
-    return createResultValue( result, renderPass, VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPass" );
-  }
-
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type
-    Device::createRenderPassUnique( const RenderPassCreateInfo &        createInfo,
-                                    Optional<const AllocationCallbacks> allocator,
-                                    Dispatch const &                    d ) const
-  {
-    VULKAN_HPP_NAMESPACE::RenderPass renderPass;
-    Result                           result = static_cast<Result>(
-      d.vkCreateRenderPass( m_device,
-                            reinterpret_cast<const VkRenderPassCreateInfo *>( &createInfo ),
-                            reinterpret_cast<const VkAllocationCallbacks *>(
-                              static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                            reinterpret_cast<VkRenderPass *>( &renderPass ) ) );
-    ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>(
-      result, renderPass, VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPassUnique", deleter );
-  }
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::createRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 * pCreateInfo,
-                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
-                               VULKAN_HPP_NAMESPACE::RenderPass *                  pRenderPass,
-                               Dispatch const &                                    d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkCreateRenderPass2( m_device,
-                                                       reinterpret_cast<const VkRenderPassCreateInfo2 *>( pCreateInfo ),
-                                                       reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
-                                                       reinterpret_cast<VkRenderPass *>( pRenderPass ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::RenderPass>::type
-    Device::createRenderPass2( const RenderPassCreateInfo2 &       createInfo,
-                               Optional<const AllocationCallbacks> allocator,
-                               Dispatch const &                    d ) const
-  {
-    VULKAN_HPP_NAMESPACE::RenderPass renderPass;
-    Result                           result = static_cast<Result>(
-      d.vkCreateRenderPass2( m_device,
-                             reinterpret_cast<const VkRenderPassCreateInfo2 *>( &createInfo ),
-                             reinterpret_cast<const VkAllocationCallbacks *>(
-                               static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                             reinterpret_cast<VkRenderPass *>( &renderPass ) ) );
-    return createResultValue( result, renderPass, VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPass2" );
-  }
-
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type
-    Device::createRenderPass2Unique( const RenderPassCreateInfo2 &       createInfo,
-                                     Optional<const AllocationCallbacks> allocator,
-                                     Dispatch const &                    d ) const
-  {
-    VULKAN_HPP_NAMESPACE::RenderPass renderPass;
-    Result                           result = static_cast<Result>(
-      d.vkCreateRenderPass2( m_device,
-                             reinterpret_cast<const VkRenderPassCreateInfo2 *>( &createInfo ),
-                             reinterpret_cast<const VkAllocationCallbacks *>(
-                               static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                             reinterpret_cast<VkRenderPass *>( &renderPass ) ) );
-    ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>(
-      result, renderPass, VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPass2Unique", deleter );
-  }
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::createRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 * pCreateInfo,
-                                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
-                                  VULKAN_HPP_NAMESPACE::RenderPass *                  pRenderPass,
-                                  Dispatch const &                                    d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkCreateRenderPass2KHR( m_device,
-                                reinterpret_cast<const VkRenderPassCreateInfo2 *>( pCreateInfo ),
-                                reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
-                                reinterpret_cast<VkRenderPass *>( pRenderPass ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::RenderPass>::type
-    Device::createRenderPass2KHR( const RenderPassCreateInfo2 &       createInfo,
-                                  Optional<const AllocationCallbacks> allocator,
-                                  Dispatch const &                    d ) const
-  {
-    VULKAN_HPP_NAMESPACE::RenderPass renderPass;
-    Result                           result = static_cast<Result>(
-      d.vkCreateRenderPass2KHR( m_device,
-                                reinterpret_cast<const VkRenderPassCreateInfo2 *>( &createInfo ),
-                                reinterpret_cast<const VkAllocationCallbacks *>(
-                                  static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                reinterpret_cast<VkRenderPass *>( &renderPass ) ) );
-    return createResultValue( result, renderPass, VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPass2KHR" );
-  }
-
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type
-    Device::createRenderPass2KHRUnique( const RenderPassCreateInfo2 &       createInfo,
-                                        Optional<const AllocationCallbacks> allocator,
-                                        Dispatch const &                    d ) const
-  {
-    VULKAN_HPP_NAMESPACE::RenderPass renderPass;
-    Result                           result = static_cast<Result>(
-      d.vkCreateRenderPass2KHR( m_device,
-                                reinterpret_cast<const VkRenderPassCreateInfo2 *>( &createInfo ),
-                                reinterpret_cast<const VkAllocationCallbacks *>(
-                                  static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                reinterpret_cast<VkRenderPass *>( &renderPass ) ) );
-    ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>(
-      result, renderPass, VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPass2KHRUnique", deleter );
-  }
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::createSampler( const VULKAN_HPP_NAMESPACE::SamplerCreateInfo *   pCreateInfo,
-                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                           VULKAN_HPP_NAMESPACE::Sampler *                   pSampler,
-                           Dispatch const &                                  d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkCreateSampler( m_device,
-                                                   reinterpret_cast<const VkSamplerCreateInfo *>( pCreateInfo ),
-                                                   reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
-                                                   reinterpret_cast<VkSampler *>( pSampler ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::Sampler>::type
-    Device::createSampler( const SamplerCreateInfo &           createInfo,
-                           Optional<const AllocationCallbacks> allocator,
-                           Dispatch const &                    d ) const
-  {
-    VULKAN_HPP_NAMESPACE::Sampler sampler;
-    Result                        result = static_cast<Result>(
-      d.vkCreateSampler( m_device,
-                         reinterpret_cast<const VkSamplerCreateInfo *>( &createInfo ),
-                         reinterpret_cast<const VkAllocationCallbacks *>(
-                           static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                         reinterpret_cast<VkSampler *>( &sampler ) ) );
-    return createResultValue( result, sampler, VULKAN_HPP_NAMESPACE_STRING "::Device::createSampler" );
-  }
-
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Sampler, Dispatch>>::type
-    Device::createSamplerUnique( const SamplerCreateInfo &           createInfo,
-                                 Optional<const AllocationCallbacks> allocator,
-                                 Dispatch const &                    d ) const
-  {
-    VULKAN_HPP_NAMESPACE::Sampler sampler;
-    Result                        result = static_cast<Result>(
-      d.vkCreateSampler( m_device,
-                         reinterpret_cast<const VkSamplerCreateInfo *>( &createInfo ),
-                         reinterpret_cast<const VkAllocationCallbacks *>(
-                           static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                         reinterpret_cast<VkSampler *>( &sampler ) ) );
-    ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<VULKAN_HPP_NAMESPACE::Sampler, Dispatch>(
-      result, sampler, VULKAN_HPP_NAMESPACE_STRING "::Device::createSamplerUnique", deleter );
-  }
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::createSamplerYcbcrConversion( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo * pCreateInfo,
-                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks *              pAllocator,
-                                          VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion * pYcbcrConversion,
-                                          Dispatch const &                               d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkCreateSamplerYcbcrConversion( m_device,
-                                        reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo *>( pCreateInfo ),
-                                        reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
-                                        reinterpret_cast<VkSamplerYcbcrConversion *>( pYcbcrConversion ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>::type
-    Device::createSamplerYcbcrConversion( const SamplerYcbcrConversionCreateInfo & createInfo,
-                                          Optional<const AllocationCallbacks>      allocator,
-                                          Dispatch const &                         d ) const
-  {
-    VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion;
-    Result                                       result = static_cast<Result>(
-      d.vkCreateSamplerYcbcrConversion( m_device,
-                                        reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo *>( &createInfo ),
-                                        reinterpret_cast<const VkAllocationCallbacks *>(
-                                          static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                        reinterpret_cast<VkSamplerYcbcrConversion *>( &ycbcrConversion ) ) );
-    return createResultValue(
-      result, ycbcrConversion, VULKAN_HPP_NAMESPACE_STRING "::Device::createSamplerYcbcrConversion" );
-  }
-
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, Dispatch>>::type
-    Device::createSamplerYcbcrConversionUnique( const SamplerYcbcrConversionCreateInfo & createInfo,
-                                                Optional<const AllocationCallbacks>      allocator,
-                                                Dispatch const &                         d ) const
-  {
-    VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion;
-    Result                                       result = static_cast<Result>(
-      d.vkCreateSamplerYcbcrConversion( m_device,
-                                        reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo *>( &createInfo ),
-                                        reinterpret_cast<const VkAllocationCallbacks *>(
-                                          static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                        reinterpret_cast<VkSamplerYcbcrConversion *>( &ycbcrConversion ) ) );
-    ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, Dispatch>(
-      result, ycbcrConversion, VULKAN_HPP_NAMESPACE_STRING "::Device::createSamplerYcbcrConversionUnique", deleter );
-  }
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::createSamplerYcbcrConversionKHR( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo * pCreateInfo,
-                                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks *              pAllocator,
-                                             VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion * pYcbcrConversion,
-                                             Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkCreateSamplerYcbcrConversionKHR( m_device,
-                                           reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo *>( pCreateInfo ),
-                                           reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
-                                           reinterpret_cast<VkSamplerYcbcrConversion *>( pYcbcrConversion ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>::type
-    Device::createSamplerYcbcrConversionKHR( const SamplerYcbcrConversionCreateInfo & createInfo,
-                                             Optional<const AllocationCallbacks>      allocator,
-                                             Dispatch const &                         d ) const
-  {
-    VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion;
-    Result                                       result = static_cast<Result>( d.vkCreateSamplerYcbcrConversionKHR(
-      m_device,
-      reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>(
-        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkSamplerYcbcrConversion *>( &ycbcrConversion ) ) );
-    return createResultValue(
-      result, ycbcrConversion, VULKAN_HPP_NAMESPACE_STRING "::Device::createSamplerYcbcrConversionKHR" );
-  }
-
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, Dispatch>>::type
-    Device::createSamplerYcbcrConversionKHRUnique( const SamplerYcbcrConversionCreateInfo & createInfo,
-                                                   Optional<const AllocationCallbacks>      allocator,
-                                                   Dispatch const &                         d ) const
-  {
-    VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion;
-    Result                                       result = static_cast<Result>( d.vkCreateSamplerYcbcrConversionKHR(
-      m_device,
-      reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>(
-        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkSamplerYcbcrConversion *>( &ycbcrConversion ) ) );
-    ObjectDestroy<Device, Dispatch>              deleter( *this, allocator, d );
-    return createResultValue<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, Dispatch>(
-      result, ycbcrConversion, VULKAN_HPP_NAMESPACE_STRING "::Device::createSamplerYcbcrConversionKHRUnique", deleter );
-  }
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::createSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo * pCreateInfo,
-                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                             VULKAN_HPP_NAMESPACE::Semaphore *                 pSemaphore,
-                             Dispatch const &                                  d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkCreateSemaphore( m_device,
-                                                     reinterpret_cast<const VkSemaphoreCreateInfo *>( pCreateInfo ),
-                                                     reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
-                                                     reinterpret_cast<VkSemaphore *>( pSemaphore ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::Semaphore>::type
-    Device::createSemaphore( const SemaphoreCreateInfo &         createInfo,
-                             Optional<const AllocationCallbacks> allocator,
-                             Dispatch const &                    d ) const
-  {
-    VULKAN_HPP_NAMESPACE::Semaphore semaphore;
-    Result                          result = static_cast<Result>(
-      d.vkCreateSemaphore( m_device,
-                           reinterpret_cast<const VkSemaphoreCreateInfo *>( &createInfo ),
-                           reinterpret_cast<const VkAllocationCallbacks *>(
-                             static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                           reinterpret_cast<VkSemaphore *>( &semaphore ) ) );
-    return createResultValue( result, semaphore, VULKAN_HPP_NAMESPACE_STRING "::Device::createSemaphore" );
-  }
-
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Semaphore, Dispatch>>::type
-    Device::createSemaphoreUnique( const SemaphoreCreateInfo &         createInfo,
-                                   Optional<const AllocationCallbacks> allocator,
-                                   Dispatch const &                    d ) const
-  {
-    VULKAN_HPP_NAMESPACE::Semaphore semaphore;
-    Result                          result = static_cast<Result>(
-      d.vkCreateSemaphore( m_device,
-                           reinterpret_cast<const VkSemaphoreCreateInfo *>( &createInfo ),
-                           reinterpret_cast<const VkAllocationCallbacks *>(
-                             static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                           reinterpret_cast<VkSemaphore *>( &semaphore ) ) );
-    ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<VULKAN_HPP_NAMESPACE::Semaphore, Dispatch>(
-      result, semaphore, VULKAN_HPP_NAMESPACE_STRING "::Device::createSemaphoreUnique", deleter );
-  }
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::createShaderModule( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo * pCreateInfo,
-                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks *    pAllocator,
-                                VULKAN_HPP_NAMESPACE::ShaderModule *                 pShaderModule,
-                                Dispatch const &                                     d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkCreateShaderModule( m_device,
-                              reinterpret_cast<const VkShaderModuleCreateInfo *>( pCreateInfo ),
-                              reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
-                              reinterpret_cast<VkShaderModule *>( pShaderModule ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::ShaderModule>::type
-    Device::createShaderModule( const ShaderModuleCreateInfo &      createInfo,
-                                Optional<const AllocationCallbacks> allocator,
-                                Dispatch const &                    d ) const
-  {
-    VULKAN_HPP_NAMESPACE::ShaderModule shaderModule;
-    Result                             result = static_cast<Result>(
-      d.vkCreateShaderModule( m_device,
-                              reinterpret_cast<const VkShaderModuleCreateInfo *>( &createInfo ),
-                              reinterpret_cast<const VkAllocationCallbacks *>(
-                                static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                              reinterpret_cast<VkShaderModule *>( &shaderModule ) ) );
-    return createResultValue( result, shaderModule, VULKAN_HPP_NAMESPACE_STRING "::Device::createShaderModule" );
-  }
-
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderModule, Dispatch>>::type
-    Device::createShaderModuleUnique( const ShaderModuleCreateInfo &      createInfo,
-                                      Optional<const AllocationCallbacks> allocator,
-                                      Dispatch const &                    d ) const
-  {
-    VULKAN_HPP_NAMESPACE::ShaderModule shaderModule;
-    Result                             result = static_cast<Result>(
-      d.vkCreateShaderModule( m_device,
-                              reinterpret_cast<const VkShaderModuleCreateInfo *>( &createInfo ),
-                              reinterpret_cast<const VkAllocationCallbacks *>(
-                                static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                              reinterpret_cast<VkShaderModule *>( &shaderModule ) ) );
-    ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<VULKAN_HPP_NAMESPACE::ShaderModule, Dispatch>(
-      result, shaderModule, VULKAN_HPP_NAMESPACE_STRING "::Device::createShaderModuleUnique", deleter );
-  }
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::createSharedSwapchainsKHR( uint32_t                                             swapchainCount,
-                                       const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR * pCreateInfos,
-                                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *    pAllocator,
-                                       VULKAN_HPP_NAMESPACE::SwapchainKHR *                 pSwapchains,
-                                       Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkCreateSharedSwapchainsKHR( m_device,
-                                     swapchainCount,
-                                     reinterpret_cast<const VkSwapchainCreateInfoKHR *>( pCreateInfos ),
-                                     reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
-                                     reinterpret_cast<VkSwapchainKHR *>( pSwapchains ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename SwapchainKHRAllocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<std::vector<SwapchainKHR, SwapchainKHRAllocator>>::type
-    Device::createSharedSwapchainsKHR(
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
-      Optional<const AllocationCallbacks>                                    allocator,
-      Dispatch const &                                                       d ) const
-  {
-    std::vector<SwapchainKHR, SwapchainKHRAllocator> swapchains( createInfos.size() );
-    Result                                           result = static_cast<Result>(
-      d.vkCreateSharedSwapchainsKHR( m_device,
-                                     createInfos.size(),
-                                     reinterpret_cast<const VkSwapchainCreateInfoKHR *>( createInfos.data() ),
-                                     reinterpret_cast<const VkAllocationCallbacks *>(
-                                       static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                     reinterpret_cast<VkSwapchainKHR *>( swapchains.data() ) ) );
-    return createResultValue( result, swapchains, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHR" );
-  }
-
-  template <typename SwapchainKHRAllocator,
-            typename Dispatch,
-            typename B,
-            typename std::enable_if<std::is_same<typename B::value_type, SwapchainKHR>::value, int>::type>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<std::vector<SwapchainKHR, SwapchainKHRAllocator>>::type
-    Device::createSharedSwapchainsKHR(
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
-      Optional<const AllocationCallbacks>                                    allocator,
-      SwapchainKHRAllocator &                                                swapchainKHRAllocator,
-      Dispatch const &                                                       d ) const
-  {
-    std::vector<SwapchainKHR, SwapchainKHRAllocator> swapchains( createInfos.size(), swapchainKHRAllocator );
-    Result                                           result = static_cast<Result>(
-      d.vkCreateSharedSwapchainsKHR( m_device,
-                                     createInfos.size(),
-                                     reinterpret_cast<const VkSwapchainCreateInfoKHR *>( createInfos.data() ),
-                                     reinterpret_cast<const VkAllocationCallbacks *>(
-                                       static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                     reinterpret_cast<VkSwapchainKHR *>( swapchains.data() ) ) );
-    return createResultValue( result, swapchains, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHR" );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<SwapchainKHR>::type
-    Device::createSharedSwapchainKHR( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR & createInfo,
-                                      Optional<const AllocationCallbacks>                  allocator,
-                                      Dispatch const &                                     d ) const
-  {
-    SwapchainKHR swapchain;
-    Result       result = static_cast<Result>(
-      d.vkCreateSharedSwapchainsKHR( m_device,
-                                     1,
-                                     reinterpret_cast<const VkSwapchainCreateInfoKHR *>( &createInfo ),
-                                     reinterpret_cast<const VkAllocationCallbacks *>(
-                                       static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                     reinterpret_cast<VkSwapchainKHR *>( &swapchain ) ) );
-    return createResultValue( result, swapchain, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainKHR" );
-  }
-
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Dispatch, typename SwapchainKHRAllocator>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR, Dispatch>, SwapchainKHRAllocator>>::type
-    Device::createSharedSwapchainsKHRUnique(
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
-      Optional<const AllocationCallbacks>                                    allocator,
-      Dispatch const &                                                       d ) const
-  {
-    std::vector<UniqueHandle<SwapchainKHR, Dispatch>, SwapchainKHRAllocator> uniqueSwapchains;
-    std::vector<SwapchainKHR>                                                swapchains( createInfos.size() );
-    Result                                                                   result = static_cast<Result>(
-      d.vkCreateSharedSwapchainsKHR( m_device,
-                                     createInfos.size(),
-                                     reinterpret_cast<const VkSwapchainCreateInfoKHR *>( createInfos.data() ),
-                                     reinterpret_cast<const VkAllocationCallbacks *>(
-                                       static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                     reinterpret_cast<VkSwapchainKHR *>( swapchains.data() ) ) );
-    if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess )
-    {
-      uniqueSwapchains.reserve( createInfos.size() );
-      ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-      for ( size_t i = 0; i < createInfos.size(); i++ )
-      {
-        uniqueSwapchains.push_back( UniqueHandle<SwapchainKHR, Dispatch>( swapchains[i], deleter ) );
-      }
-    }
-    return createResultValue(
-      result, std::move( uniqueSwapchains ), VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHRUnique" );
-  }
-
-  template <typename Dispatch,
-            typename SwapchainKHRAllocator,
-            typename B,
-            typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<SwapchainKHR, Dispatch>>::value,
-                                    int>::type>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR, Dispatch>, SwapchainKHRAllocator>>::type
-    Device::createSharedSwapchainsKHRUnique(
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
-      Optional<const AllocationCallbacks>                                    allocator,
-      SwapchainKHRAllocator &                                                swapchainKHRAllocator,
-      Dispatch const &                                                       d ) const
-  {
-    std::vector<UniqueHandle<SwapchainKHR, Dispatch>, SwapchainKHRAllocator> uniqueSwapchains( swapchainKHRAllocator );
-    std::vector<SwapchainKHR>                                                swapchains( createInfos.size() );
-    Result                                                                   result = static_cast<Result>(
-      d.vkCreateSharedSwapchainsKHR( m_device,
-                                     createInfos.size(),
-                                     reinterpret_cast<const VkSwapchainCreateInfoKHR *>( createInfos.data() ),
-                                     reinterpret_cast<const VkAllocationCallbacks *>(
-                                       static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                     reinterpret_cast<VkSwapchainKHR *>( swapchains.data() ) ) );
-    if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess )
-    {
-      uniqueSwapchains.reserve( createInfos.size() );
-      ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-      for ( size_t i = 0; i < createInfos.size(); i++ )
-      {
-        uniqueSwapchains.push_back( UniqueHandle<SwapchainKHR, Dispatch>( swapchains[i], deleter ) );
-      }
-    }
-    return createResultValue(
-      result, std::move( uniqueSwapchains ), VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHRUnique" );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<SwapchainKHR, Dispatch>>::type
-    Device::createSharedSwapchainKHRUnique( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR & createInfo,
-                                            Optional<const AllocationCallbacks>                  allocator,
-                                            Dispatch const &                                     d ) const
-  {
-    SwapchainKHR swapchain;
-    Result       result = static_cast<Result>(
-      d.vkCreateSharedSwapchainsKHR( m_device,
-                                     1,
-                                     reinterpret_cast<const VkSwapchainCreateInfoKHR *>( &createInfo ),
-                                     reinterpret_cast<const VkAllocationCallbacks *>(
-                                       static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                     reinterpret_cast<VkSwapchainKHR *>( &swapchain ) ) );
-    ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<SwapchainKHR, Dispatch>(
-      result, swapchain, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainKHRUnique", deleter );
-  }
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::createSwapchainKHR( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR * pCreateInfo,
-                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks *    pAllocator,
-                                VULKAN_HPP_NAMESPACE::SwapchainKHR *                 pSwapchain,
-                                Dispatch const &                                     d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkCreateSwapchainKHR( m_device,
-                              reinterpret_cast<const VkSwapchainCreateInfoKHR *>( pCreateInfo ),
-                              reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
-                              reinterpret_cast<VkSwapchainKHR *>( pSwapchain ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::SwapchainKHR>::type
-    Device::createSwapchainKHR( const SwapchainCreateInfoKHR &      createInfo,
-                                Optional<const AllocationCallbacks> allocator,
-                                Dispatch const &                    d ) const
-  {
-    VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain;
-    Result                             result = static_cast<Result>(
-      d.vkCreateSwapchainKHR( m_device,
-                              reinterpret_cast<const VkSwapchainCreateInfoKHR *>( &createInfo ),
-                              reinterpret_cast<const VkAllocationCallbacks *>(
-                                static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                              reinterpret_cast<VkSwapchainKHR *>( &swapchain ) ) );
-    return createResultValue( result, swapchain, VULKAN_HPP_NAMESPACE_STRING "::Device::createSwapchainKHR" );
-  }
-
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>::type
-    Device::createSwapchainKHRUnique( const SwapchainCreateInfoKHR &      createInfo,
-                                      Optional<const AllocationCallbacks> allocator,
-                                      Dispatch const &                    d ) const
-  {
-    VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain;
-    Result                             result = static_cast<Result>(
-      d.vkCreateSwapchainKHR( m_device,
-                              reinterpret_cast<const VkSwapchainCreateInfoKHR *>( &createInfo ),
-                              reinterpret_cast<const VkAllocationCallbacks *>(
-                                static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                              reinterpret_cast<VkSwapchainKHR *>( &swapchain ) ) );
-    ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>(
-      result, swapchain, VULKAN_HPP_NAMESPACE_STRING "::Device::createSwapchainKHRUnique", deleter );
-  }
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::createValidationCacheEXT( const VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT * pCreateInfo,
-                                      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *          pAllocator,
-                                      VULKAN_HPP_NAMESPACE::ValidationCacheEXT *                 pValidationCache,
-                                      Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkCreateValidationCacheEXT( m_device,
-                                    reinterpret_cast<const VkValidationCacheCreateInfoEXT *>( pCreateInfo ),
-                                    reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
-                                    reinterpret_cast<VkValidationCacheEXT *>( pValidationCache ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::ValidationCacheEXT>::type
-    Device::createValidationCacheEXT( const ValidationCacheCreateInfoEXT & createInfo,
-                                      Optional<const AllocationCallbacks>  allocator,
-                                      Dispatch const &                     d ) const
-  {
-    VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache;
-    Result                                   result = static_cast<Result>(
-      d.vkCreateValidationCacheEXT( m_device,
-                                    reinterpret_cast<const VkValidationCacheCreateInfoEXT *>( &createInfo ),
-                                    reinterpret_cast<const VkAllocationCallbacks *>(
-                                      static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                    reinterpret_cast<VkValidationCacheEXT *>( &validationCache ) ) );
-    return createResultValue(
-      result, validationCache, VULKAN_HPP_NAMESPACE_STRING "::Device::createValidationCacheEXT" );
-  }
-
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ValidationCacheEXT, Dispatch>>::type
-    Device::createValidationCacheEXTUnique( const ValidationCacheCreateInfoEXT & createInfo,
-                                            Optional<const AllocationCallbacks>  allocator,
-                                            Dispatch const &                     d ) const
-  {
-    VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache;
-    Result                                   result = static_cast<Result>(
-      d.vkCreateValidationCacheEXT( m_device,
-                                    reinterpret_cast<const VkValidationCacheCreateInfoEXT *>( &createInfo ),
-                                    reinterpret_cast<const VkAllocationCallbacks *>(
-                                      static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                    reinterpret_cast<VkValidationCacheEXT *>( &validationCache ) ) );
-    ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<VULKAN_HPP_NAMESPACE::ValidationCacheEXT, Dispatch>(
-      result, validationCache, VULKAN_HPP_NAMESPACE_STRING "::Device::createValidationCacheEXTUnique", deleter );
-  }
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#if defined( VK_ENABLE_BETA_EXTENSIONS )
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::createVideoSessionKHR( const VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR * pCreateInfo,
-                                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,
-                                   VULKAN_HPP_NAMESPACE::VideoSessionKHR *                 pVideoSession,
-                                   Dispatch const &                                        d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkCreateVideoSessionKHR( m_device,
-                                 reinterpret_cast<const VkVideoSessionCreateInfoKHR *>( pCreateInfo ),
-                                 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
-                                 reinterpret_cast<VkVideoSessionKHR *>( pVideoSession ) ) );
-  }
-
-#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoSessionKHR>::type
-    Device::createVideoSessionKHR( const VideoSessionCreateInfoKHR &   createInfo,
-                                   Optional<const AllocationCallbacks> allocator,
-                                   Dispatch const &                    d ) const
-  {
-    VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession;
-    Result                                result = static_cast<Result>(
-      d.vkCreateVideoSessionKHR( m_device,
-                                 reinterpret_cast<const VkVideoSessionCreateInfoKHR *>( &createInfo ),
-                                 reinterpret_cast<const VkAllocationCallbacks *>(
-                                   static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                 reinterpret_cast<VkVideoSessionKHR *>( &videoSession ) ) );
-    return createResultValue( result, videoSession, VULKAN_HPP_NAMESPACE_STRING "::Device::createVideoSessionKHR" );
-  }
-
-#    ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::VideoSessionKHR, Dispatch>>::type
-    Device::createVideoSessionKHRUnique( const VideoSessionCreateInfoKHR &   createInfo,
-                                         Optional<const AllocationCallbacks> allocator,
-                                         Dispatch const &                    d ) const
-  {
-    VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession;
-    Result                                result = static_cast<Result>(
-      d.vkCreateVideoSessionKHR( m_device,
-                                 reinterpret_cast<const VkVideoSessionCreateInfoKHR *>( &createInfo ),
-                                 reinterpret_cast<const VkAllocationCallbacks *>(
-                                   static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                 reinterpret_cast<VkVideoSessionKHR *>( &videoSession ) ) );
-    ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<VULKAN_HPP_NAMESPACE::VideoSessionKHR, Dispatch>(
-      result, videoSession, VULKAN_HPP_NAMESPACE_STRING "::Device::createVideoSessionKHRUnique", deleter );
-  }
-#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif     /*VK_ENABLE_BETA_EXTENSIONS*/
-
-#if defined( VK_ENABLE_BETA_EXTENSIONS )
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createVideoSessionParametersKHR(
-    const VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR * pCreateInfo,
-    const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                 pAllocator,
-    VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR *                 pVideoSessionParameters,
-    Dispatch const &                                                  d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkCreateVideoSessionParametersKHR(
-      m_device,
-      reinterpret_cast<const VkVideoSessionParametersCreateInfoKHR *>( pCreateInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
-      reinterpret_cast<VkVideoSessionParametersKHR *>( pVideoSessionParameters ) ) );
-  }
-
-#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR>::type
-    Device::createVideoSessionParametersKHR( const VideoSessionParametersCreateInfoKHR & createInfo,
-                                             Optional<const AllocationCallbacks>         allocator,
-                                             Dispatch const &                            d ) const
-  {
-    VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters;
-    Result                                          result = static_cast<Result>( d.vkCreateVideoSessionParametersKHR(
-      m_device,
-      reinterpret_cast<const VkVideoSessionParametersCreateInfoKHR *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>(
-        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkVideoSessionParametersKHR *>( &videoSessionParameters ) ) );
-    return createResultValue(
-      result, videoSessionParameters, VULKAN_HPP_NAMESPACE_STRING "::Device::createVideoSessionParametersKHR" );
-  }
-
-#    ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR, Dispatch>>::type
-    Device::createVideoSessionParametersKHRUnique( const VideoSessionParametersCreateInfoKHR & createInfo,
-                                                   Optional<const AllocationCallbacks>         allocator,
-                                                   Dispatch const &                            d ) const
-  {
-    VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters;
-    Result                                          result = static_cast<Result>( d.vkCreateVideoSessionParametersKHR(
-      m_device,
-      reinterpret_cast<const VkVideoSessionParametersCreateInfoKHR *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>(
-        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkVideoSessionParametersKHR *>( &videoSessionParameters ) ) );
-    ObjectDestroy<Device, Dispatch>                 deleter( *this, allocator, d );
-    return createResultValue<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR, Dispatch>(
-      result,
-      videoSessionParameters,
-      VULKAN_HPP_NAMESPACE_STRING "::Device::createVideoSessionParametersKHRUnique",
-      deleter );
-  }
-#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif     /*VK_ENABLE_BETA_EXTENSIONS*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::debugMarkerSetObjectNameEXT(
-    const VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT * pNameInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkDebugMarkerSetObjectNameEXT(
-      m_device, reinterpret_cast<const VkDebugMarkerObjectNameInfoEXT *>( pNameInfo ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
-    Device::debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT & nameInfo, Dispatch const & d ) const
-  {
-    Result result = static_cast<Result>( d.vkDebugMarkerSetObjectNameEXT(
-      m_device, reinterpret_cast<const VkDebugMarkerObjectNameInfoEXT *>( &nameInfo ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::debugMarkerSetObjectNameEXT" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::debugMarkerSetObjectTagEXT(
-    const VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT * pTagInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkDebugMarkerSetObjectTagEXT( m_device, reinterpret_cast<const VkDebugMarkerObjectTagInfoEXT *>( pTagInfo ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
-    Device::debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT & tagInfo, Dispatch const & d ) const
-  {
-    Result result = static_cast<Result>(
-      d.vkDebugMarkerSetObjectTagEXT( m_device, reinterpret_cast<const VkDebugMarkerObjectTagInfoEXT *>( &tagInfo ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::debugMarkerSetObjectTagEXT" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::deferredOperationJoinKHR(
-    VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkDeferredOperationJoinKHR( m_device, static_cast<VkDeferredOperationKHR>( operation ) ) );
-  }
-#else
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::deferredOperationJoinKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, Dispatch const & d ) const
-  {
-    Result result =
-      static_cast<Result>( d.vkDeferredOperationJoinKHR( m_device, static_cast<VkDeferredOperationKHR>( operation ) ) );
-    return createResultValue( result,
-                              VULKAN_HPP_NAMESPACE_STRING "::Device::deferredOperationJoinKHR",
-                              { VULKAN_HPP_NAMESPACE::Result::eSuccess,
-                                VULKAN_HPP_NAMESPACE::Result::eThreadDoneKHR,
-                                VULKAN_HPP_NAMESPACE::Result::eThreadIdleKHR } );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    Device::destroyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR    accelerationStructure,
-                                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                             Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyAccelerationStructureKHR( 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::destroyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure,
-                                             Optional<const AllocationCallbacks>            allocator,
-                                             Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyAccelerationStructureKHR(
-      m_device,
-      static_cast<VkAccelerationStructureKHR>( accelerationStructure ),
-      reinterpret_cast<const VkAllocationCallbacks *>(
-        static_cast<const VULKAN_HPP_NAMESPACE::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,
-                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyAccelerationStructureKHR( 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::destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure,
-                                          Optional<const AllocationCallbacks>            allocator,
-                                          Dispatch const &                               d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyAccelerationStructureKHR(
-      m_device,
-      static_cast<VkAccelerationStructureKHR>( accelerationStructure ),
-      reinterpret_cast<const VkAllocationCallbacks *>(
-        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    Device::destroyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV     accelerationStructure,
-                                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                            Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyAccelerationStructureNV( m_device,
-                                        static_cast<VkAccelerationStructureNV>( accelerationStructure ),
-                                        reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    Device::destroyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
-                                            Optional<const AllocationCallbacks>           allocator,
-                                            Dispatch const &                              d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyAccelerationStructureNV(
-      m_device,
-      static_cast<VkAccelerationStructureNV>( accelerationStructure ),
-      reinterpret_cast<const VkAllocationCallbacks *>(
-        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureNV     accelerationStructure,
-                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyAccelerationStructureNV( m_device,
-                                        static_cast<VkAccelerationStructureNV>( accelerationStructure ),
-                                        reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
-                                          Optional<const AllocationCallbacks>           allocator,
-                                          Dispatch const &                              d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyAccelerationStructureNV(
-      m_device,
-      static_cast<VkAccelerationStructureNV>( accelerationStructure ),
-      reinterpret_cast<const VkAllocationCallbacks *>(
-        static_cast<const VULKAN_HPP_NAMESPACE::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,
-                                                Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyBuffer(
-      m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyBuffer( VULKAN_HPP_NAMESPACE::Buffer        buffer,
-                                                Optional<const AllocationCallbacks> allocator,
-                                                Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyBuffer( m_device,
-                       static_cast<VkBuffer>( buffer ),
-                       reinterpret_cast<const VkAllocationCallbacks *>(
-                         static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Buffer                      buffer,
-                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyBuffer(
-      m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Buffer        buffer,
-                                          Optional<const AllocationCallbacks> allocator,
-                                          Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyBuffer( m_device,
-                       static_cast<VkBuffer>( buffer ),
-                       reinterpret_cast<const VkAllocationCallbacks *>(
-                         static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyBufferView( VULKAN_HPP_NAMESPACE::BufferView                  bufferView,
-                                                    const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                                    Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyBufferView( m_device,
-                           static_cast<VkBufferView>( bufferView ),
-                           reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyBufferView( VULKAN_HPP_NAMESPACE::BufferView    bufferView,
-                                                    Optional<const AllocationCallbacks> allocator,
-                                                    Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyBufferView( m_device,
-                           static_cast<VkBufferView>( bufferView ),
-                           reinterpret_cast<const VkAllocationCallbacks *>(
-                             static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::BufferView                  bufferView,
-                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyBufferView( m_device,
-                           static_cast<VkBufferView>( bufferView ),
-                           reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::BufferView    bufferView,
-                                          Optional<const AllocationCallbacks> allocator,
-                                          Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyBufferView( m_device,
-                           static_cast<VkBufferView>( bufferView ),
-                           reinterpret_cast<const VkAllocationCallbacks *>(
-                             static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyCommandPool( VULKAN_HPP_NAMESPACE::CommandPool                 commandPool,
-                                                     const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                                     Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyCommandPool( m_device,
-                            static_cast<VkCommandPool>( commandPool ),
-                            reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyCommandPool( VULKAN_HPP_NAMESPACE::CommandPool   commandPool,
-                                                     Optional<const AllocationCallbacks> allocator,
-                                                     Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyCommandPool( m_device,
-                            static_cast<VkCommandPool>( commandPool ),
-                            reinterpret_cast<const VkAllocationCallbacks *>(
-                              static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::CommandPool                 commandPool,
-                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyCommandPool( m_device,
-                            static_cast<VkCommandPool>( commandPool ),
-                            reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::CommandPool   commandPool,
-                                          Optional<const AllocationCallbacks> allocator,
-                                          Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyCommandPool( m_device,
-                            static_cast<VkCommandPool>( commandPool ),
-                            reinterpret_cast<const VkAllocationCallbacks *>(
-                              static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyCuFunctionNVX( VULKAN_HPP_NAMESPACE::CuFunctionNVX               function,
-                                                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                                       Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyCuFunctionNVX( m_device,
-                              static_cast<VkCuFunctionNVX>( function ),
-                              reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyCuFunctionNVX( VULKAN_HPP_NAMESPACE::CuFunctionNVX function,
-                                                       Optional<const AllocationCallbacks> allocator,
-                                                       Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyCuFunctionNVX( m_device,
-                              static_cast<VkCuFunctionNVX>( function ),
-                              reinterpret_cast<const VkAllocationCallbacks *>(
-                                static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::CuFunctionNVX               function,
-                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyCuFunctionNVX( m_device,
-                              static_cast<VkCuFunctionNVX>( function ),
-                              reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::CuFunctionNVX function,
-                                          Optional<const AllocationCallbacks> allocator,
-                                          Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyCuFunctionNVX( m_device,
-                              static_cast<VkCuFunctionNVX>( function ),
-                              reinterpret_cast<const VkAllocationCallbacks *>(
-                                static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyCuModuleNVX( VULKAN_HPP_NAMESPACE::CuModuleNVX                 module,
-                                                     const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                                     Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyCuModuleNVX(
-      m_device, static_cast<VkCuModuleNVX>( module ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyCuModuleNVX( VULKAN_HPP_NAMESPACE::CuModuleNVX   module,
-                                                     Optional<const AllocationCallbacks> allocator,
-                                                     Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyCuModuleNVX( m_device,
-                            static_cast<VkCuModuleNVX>( module ),
-                            reinterpret_cast<const VkAllocationCallbacks *>(
-                              static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::CuModuleNVX                 module,
-                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyCuModuleNVX(
-      m_device, static_cast<VkCuModuleNVX>( module ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::CuModuleNVX   module,
-                                          Optional<const AllocationCallbacks> allocator,
-                                          Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyCuModuleNVX( m_device,
-                            static_cast<VkCuModuleNVX>( module ),
-                            reinterpret_cast<const VkAllocationCallbacks *>(
-                              static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    Device::destroyDeferredOperationKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR        operation,
-                                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                         Dispatch const &                                  d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyDeferredOperationKHR( m_device,
-                                     static_cast<VkDeferredOperationKHR>( operation ),
-                                     reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyDeferredOperationKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
-                                                              Optional<const AllocationCallbacks>        allocator,
-                                                              Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyDeferredOperationKHR( m_device,
-                                     static_cast<VkDeferredOperationKHR>( operation ),
-                                     reinterpret_cast<const VkAllocationCallbacks *>(
-                                       static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::DeferredOperationKHR        operation,
-                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyDeferredOperationKHR( m_device,
-                                     static_cast<VkDeferredOperationKHR>( operation ),
-                                     reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
-                                          Optional<const AllocationCallbacks>        allocator,
-                                          Dispatch const &                           d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyDeferredOperationKHR( m_device,
-                                     static_cast<VkDeferredOperationKHR>( operation ),
-                                     reinterpret_cast<const VkAllocationCallbacks *>(
-                                       static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool,
-                                                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                                        Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyDescriptorPool( m_device,
-                               static_cast<VkDescriptorPool>( descriptorPool ),
-                               reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool,
-                                                        Optional<const AllocationCallbacks>  allocator,
-                                                        Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyDescriptorPool( m_device,
-                               static_cast<VkDescriptorPool>( descriptorPool ),
-                               reinterpret_cast<const VkAllocationCallbacks *>(
-                                 static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::DescriptorPool              descriptorPool,
-                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyDescriptorPool( m_device,
-                               static_cast<VkDescriptorPool>( descriptorPool ),
-                               reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool,
-                                          Optional<const AllocationCallbacks>  allocator,
-                                          Dispatch const &                     d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyDescriptorPool( m_device,
-                               static_cast<VkDescriptorPool>( descriptorPool ),
-                               reinterpret_cast<const VkAllocationCallbacks *>(
-                                 static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    Device::destroyDescriptorSetLayout( VULKAN_HPP_NAMESPACE::DescriptorSetLayout         descriptorSetLayout,
-                                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                        Dispatch const &                                  d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyDescriptorSetLayout( m_device,
-                                    static_cast<VkDescriptorSetLayout>( descriptorSetLayout ),
-                                    reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    Device::destroyDescriptorSetLayout( VULKAN_HPP_NAMESPACE::DescriptorSetLayout descriptorSetLayout,
-                                        Optional<const AllocationCallbacks>       allocator,
-                                        Dispatch const &                          d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyDescriptorSetLayout( m_device,
-                                    static_cast<VkDescriptorSetLayout>( descriptorSetLayout ),
-                                    reinterpret_cast<const VkAllocationCallbacks *>(
-                                      static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::DescriptorSetLayout         descriptorSetLayout,
-                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyDescriptorSetLayout( m_device,
-                                    static_cast<VkDescriptorSetLayout>( descriptorSetLayout ),
-                                    reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::DescriptorSetLayout descriptorSetLayout,
-                                          Optional<const AllocationCallbacks>       allocator,
-                                          Dispatch const &                          d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyDescriptorSetLayout( m_device,
-                                    static_cast<VkDescriptorSetLayout>( descriptorSetLayout ),
-                                    reinterpret_cast<const VkAllocationCallbacks *>(
-                                      static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    Device::destroyDescriptorUpdateTemplate( 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::destroyDescriptorUpdateTemplate( 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 VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#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 VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    Device::destroyDescriptorUpdateTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
-                                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                                Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyDescriptorUpdateTemplateKHR( m_device,
-                                            static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
-                                            reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    Device::destroyDescriptorUpdateTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
-                                                Optional<const AllocationCallbacks>            allocator,
-                                                Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyDescriptorUpdateTemplateKHR(
-      m_device,
-      static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
-      reinterpret_cast<const VkAllocationCallbacks *>(
-        static_cast<const VULKAN_HPP_NAMESPACE::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
-  {
-    d.vkDestroyDevice( m_device, reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( Optional<const AllocationCallbacks> allocator,
-                                          Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyDevice( m_device,
-                       reinterpret_cast<const VkAllocationCallbacks *>(
-                         static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyEvent( VULKAN_HPP_NAMESPACE::Event                       event,
-                                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                               Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyEvent(
-      m_device, static_cast<VkEvent>( event ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyEvent( VULKAN_HPP_NAMESPACE::Event         event,
-                                               Optional<const AllocationCallbacks> allocator,
-                                               Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyEvent( m_device,
-                      static_cast<VkEvent>( event ),
-                      reinterpret_cast<const VkAllocationCallbacks *>(
-                        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Event                       event,
-                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyEvent(
-      m_device, static_cast<VkEvent>( event ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Event         event,
-                                          Optional<const AllocationCallbacks> allocator,
-                                          Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyEvent( m_device,
-                      static_cast<VkEvent>( event ),
-                      reinterpret_cast<const VkAllocationCallbacks *>(
-                        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyFence( VULKAN_HPP_NAMESPACE::Fence                       fence,
-                                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                               Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyFence(
-      m_device, static_cast<VkFence>( fence ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyFence( VULKAN_HPP_NAMESPACE::Fence         fence,
-                                               Optional<const AllocationCallbacks> allocator,
-                                               Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyFence( m_device,
-                      static_cast<VkFence>( fence ),
-                      reinterpret_cast<const VkAllocationCallbacks *>(
-                        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Fence                       fence,
-                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyFence(
-      m_device, static_cast<VkFence>( fence ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Fence         fence,
-                                          Optional<const AllocationCallbacks> allocator,
-                                          Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyFence( m_device,
-                      static_cast<VkFence>( fence ),
-                      reinterpret_cast<const VkAllocationCallbacks *>(
-                        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyFramebuffer( VULKAN_HPP_NAMESPACE::Framebuffer                 framebuffer,
-                                                     const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                                     Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyFramebuffer( m_device,
-                            static_cast<VkFramebuffer>( framebuffer ),
-                            reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyFramebuffer( VULKAN_HPP_NAMESPACE::Framebuffer   framebuffer,
-                                                     Optional<const AllocationCallbacks> allocator,
-                                                     Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyFramebuffer( m_device,
-                            static_cast<VkFramebuffer>( framebuffer ),
-                            reinterpret_cast<const VkAllocationCallbacks *>(
-                              static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Framebuffer                 framebuffer,
-                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyFramebuffer( m_device,
-                            static_cast<VkFramebuffer>( framebuffer ),
-                            reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Framebuffer   framebuffer,
-                                          Optional<const AllocationCallbacks> allocator,
-                                          Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyFramebuffer( m_device,
-                            static_cast<VkFramebuffer>( framebuffer ),
-                            reinterpret_cast<const VkAllocationCallbacks *>(
-                              static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyImage( VULKAN_HPP_NAMESPACE::Image                       image,
-                                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                               Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyImage(
-      m_device, static_cast<VkImage>( image ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyImage( VULKAN_HPP_NAMESPACE::Image         image,
-                                               Optional<const AllocationCallbacks> allocator,
-                                               Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyImage( m_device,
-                      static_cast<VkImage>( image ),
-                      reinterpret_cast<const VkAllocationCallbacks *>(
-                        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Image                       image,
-                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyImage(
-      m_device, static_cast<VkImage>( image ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Image         image,
-                                          Optional<const AllocationCallbacks> allocator,
-                                          Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyImage( m_device,
-                      static_cast<VkImage>( image ),
-                      reinterpret_cast<const VkAllocationCallbacks *>(
-                        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyImageView( VULKAN_HPP_NAMESPACE::ImageView                   imageView,
-                                                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                                   Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyImageView(
-      m_device, static_cast<VkImageView>( imageView ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyImageView( VULKAN_HPP_NAMESPACE::ImageView     imageView,
-                                                   Optional<const AllocationCallbacks> allocator,
-                                                   Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyImageView( m_device,
-                          static_cast<VkImageView>( imageView ),
-                          reinterpret_cast<const VkAllocationCallbacks *>(
-                            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::ImageView                   imageView,
-                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyImageView(
-      m_device, static_cast<VkImageView>( imageView ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::ImageView     imageView,
-                                          Optional<const AllocationCallbacks> allocator,
-                                          Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyImageView( m_device,
-                          static_cast<VkImageView>( imageView ),
-                          reinterpret_cast<const VkAllocationCallbacks *>(
-                            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    Device::destroyIndirectCommandsLayoutNV( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV    indirectCommandsLayout,
-                                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                             Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyIndirectCommandsLayoutNV( m_device,
-                                         static_cast<VkIndirectCommandsLayoutNV>( indirectCommandsLayout ),
-                                         reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    Device::destroyIndirectCommandsLayoutNV( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout,
-                                             Optional<const AllocationCallbacks>            allocator,
-                                             Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyIndirectCommandsLayoutNV(
-      m_device,
-      static_cast<VkIndirectCommandsLayoutNV>( indirectCommandsLayout ),
-      reinterpret_cast<const VkAllocationCallbacks *>(
-        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV    indirectCommandsLayout,
-                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyIndirectCommandsLayoutNV( m_device,
-                                         static_cast<VkIndirectCommandsLayoutNV>( indirectCommandsLayout ),
-                                         reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout,
-                                          Optional<const AllocationCallbacks>            allocator,
-                                          Dispatch const &                               d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyIndirectCommandsLayoutNV(
-      m_device,
-      static_cast<VkIndirectCommandsLayoutNV>( indirectCommandsLayout ),
-      reinterpret_cast<const VkAllocationCallbacks *>(
-        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyPipeline( VULKAN_HPP_NAMESPACE::Pipeline                    pipeline,
-                                                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                                  Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyPipeline(
-      m_device, static_cast<VkPipeline>( pipeline ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyPipeline( VULKAN_HPP_NAMESPACE::Pipeline      pipeline,
-                                                  Optional<const AllocationCallbacks> allocator,
-                                                  Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyPipeline( m_device,
-                         static_cast<VkPipeline>( pipeline ),
-                         reinterpret_cast<const VkAllocationCallbacks *>(
-                           static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Pipeline                    pipeline,
-                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyPipeline(
-      m_device, static_cast<VkPipeline>( pipeline ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Pipeline      pipeline,
-                                          Optional<const AllocationCallbacks> allocator,
-                                          Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyPipeline( m_device,
-                         static_cast<VkPipeline>( pipeline ),
-                         reinterpret_cast<const VkAllocationCallbacks *>(
-                           static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyPipelineCache( VULKAN_HPP_NAMESPACE::PipelineCache               pipelineCache,
-                                                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                                       Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyPipelineCache( m_device,
-                              static_cast<VkPipelineCache>( pipelineCache ),
-                              reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyPipelineCache( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
-                                                       Optional<const AllocationCallbacks> allocator,
-                                                       Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyPipelineCache( m_device,
-                              static_cast<VkPipelineCache>( pipelineCache ),
-                              reinterpret_cast<const VkAllocationCallbacks *>(
-                                static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::PipelineCache               pipelineCache,
-                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyPipelineCache( m_device,
-                              static_cast<VkPipelineCache>( pipelineCache ),
-                              reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
-                                          Optional<const AllocationCallbacks> allocator,
-                                          Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyPipelineCache( m_device,
-                              static_cast<VkPipelineCache>( pipelineCache ),
-                              reinterpret_cast<const VkAllocationCallbacks *>(
-                                static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyPipelineLayout( VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout,
-                                                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                                        Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyPipelineLayout( m_device,
-                               static_cast<VkPipelineLayout>( pipelineLayout ),
-                               reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyPipelineLayout( VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout,
-                                                        Optional<const AllocationCallbacks>  allocator,
-                                                        Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyPipelineLayout( m_device,
-                               static_cast<VkPipelineLayout>( pipelineLayout ),
-                               reinterpret_cast<const VkAllocationCallbacks *>(
-                                 static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::PipelineLayout              pipelineLayout,
-                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyPipelineLayout( m_device,
-                               static_cast<VkPipelineLayout>( pipelineLayout ),
-                               reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout,
-                                          Optional<const AllocationCallbacks>  allocator,
-                                          Dispatch const &                     d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyPipelineLayout( m_device,
-                               static_cast<VkPipelineLayout>( pipelineLayout ),
-                               reinterpret_cast<const VkAllocationCallbacks *>(
-                                 static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    Device::destroyPrivateDataSlotEXT( VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT          privateDataSlot,
-                                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                       Dispatch const &                                  d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyPrivateDataSlotEXT( m_device,
-                                   static_cast<VkPrivateDataSlotEXT>( privateDataSlot ),
-                                   reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyPrivateDataSlotEXT( VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot,
-                                                            Optional<const AllocationCallbacks>      allocator,
-                                                            Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyPrivateDataSlotEXT( m_device,
-                                   static_cast<VkPrivateDataSlotEXT>( privateDataSlot ),
-                                   reinterpret_cast<const VkAllocationCallbacks *>(
-                                     static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT          privateDataSlot,
-                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyPrivateDataSlotEXT( m_device,
-                                   static_cast<VkPrivateDataSlotEXT>( privateDataSlot ),
-                                   reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot,
-                                          Optional<const AllocationCallbacks>      allocator,
-                                          Dispatch const &                         d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyPrivateDataSlotEXT( m_device,
-                                   static_cast<VkPrivateDataSlotEXT>( privateDataSlot ),
-                                   reinterpret_cast<const VkAllocationCallbacks *>(
-                                     static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyQueryPool( VULKAN_HPP_NAMESPACE::QueryPool                   queryPool,
-                                                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                                   Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyQueryPool(
-      m_device, static_cast<VkQueryPool>( queryPool ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyQueryPool( VULKAN_HPP_NAMESPACE::QueryPool     queryPool,
-                                                   Optional<const AllocationCallbacks> allocator,
-                                                   Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyQueryPool( m_device,
-                          static_cast<VkQueryPool>( queryPool ),
-                          reinterpret_cast<const VkAllocationCallbacks *>(
-                            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::QueryPool                   queryPool,
-                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyQueryPool(
-      m_device, static_cast<VkQueryPool>( queryPool ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::QueryPool     queryPool,
-                                          Optional<const AllocationCallbacks> allocator,
-                                          Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyQueryPool( m_device,
-                          static_cast<VkQueryPool>( queryPool ),
-                          reinterpret_cast<const VkAllocationCallbacks *>(
-                            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyRenderPass( VULKAN_HPP_NAMESPACE::RenderPass                  renderPass,
-                                                    const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                                    Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyRenderPass( m_device,
-                           static_cast<VkRenderPass>( renderPass ),
-                           reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyRenderPass( VULKAN_HPP_NAMESPACE::RenderPass    renderPass,
-                                                    Optional<const AllocationCallbacks> allocator,
-                                                    Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyRenderPass( m_device,
-                           static_cast<VkRenderPass>( renderPass ),
-                           reinterpret_cast<const VkAllocationCallbacks *>(
-                             static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::RenderPass                  renderPass,
-                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyRenderPass( m_device,
-                           static_cast<VkRenderPass>( renderPass ),
-                           reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::RenderPass    renderPass,
-                                          Optional<const AllocationCallbacks> allocator,
-                                          Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyRenderPass( m_device,
-                           static_cast<VkRenderPass>( renderPass ),
-                           reinterpret_cast<const VkAllocationCallbacks *>(
-                             static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroySampler( VULKAN_HPP_NAMESPACE::Sampler                     sampler,
-                                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                                 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroySampler(
-      m_device, static_cast<VkSampler>( sampler ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroySampler( VULKAN_HPP_NAMESPACE::Sampler       sampler,
-                                                 Optional<const AllocationCallbacks> allocator,
-                                                 Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroySampler( m_device,
-                        static_cast<VkSampler>( sampler ),
-                        reinterpret_cast<const VkAllocationCallbacks *>(
-                          static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Sampler                     sampler,
-                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroySampler(
-      m_device, static_cast<VkSampler>( sampler ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Sampler       sampler,
-                                          Optional<const AllocationCallbacks> allocator,
-                                          Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroySampler( m_device,
-                        static_cast<VkSampler>( sampler ),
-                        reinterpret_cast<const VkAllocationCallbacks *>(
-                          static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    Device::destroySamplerYcbcrConversion( 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::destroySamplerYcbcrConversion( 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 VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#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 VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    Device::destroySamplerYcbcrConversionKHR( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion      ycbcrConversion,
-                                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                              Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroySamplerYcbcrConversionKHR( 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::destroySamplerYcbcrConversionKHR( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion,
-                                              Optional<const AllocationCallbacks>          allocator,
-                                              Dispatch const &                             d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroySamplerYcbcrConversionKHR(
-      m_device,
-      static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ),
-      reinterpret_cast<const VkAllocationCallbacks *>(
-        static_cast<const VULKAN_HPP_NAMESPACE::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,
-                                                   Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroySemaphore(
-      m_device, static_cast<VkSemaphore>( semaphore ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroySemaphore( VULKAN_HPP_NAMESPACE::Semaphore     semaphore,
-                                                   Optional<const AllocationCallbacks> allocator,
-                                                   Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroySemaphore( m_device,
-                          static_cast<VkSemaphore>( semaphore ),
-                          reinterpret_cast<const VkAllocationCallbacks *>(
-                            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Semaphore                   semaphore,
-                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroySemaphore(
-      m_device, static_cast<VkSemaphore>( semaphore ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::Semaphore     semaphore,
-                                          Optional<const AllocationCallbacks> allocator,
-                                          Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroySemaphore( m_device,
-                          static_cast<VkSemaphore>( semaphore ),
-                          reinterpret_cast<const VkAllocationCallbacks *>(
-                            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyShaderModule( VULKAN_HPP_NAMESPACE::ShaderModule                shaderModule,
-                                                      const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                                      Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyShaderModule( m_device,
-                             static_cast<VkShaderModule>( shaderModule ),
-                             reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyShaderModule( VULKAN_HPP_NAMESPACE::ShaderModule  shaderModule,
-                                                      Optional<const AllocationCallbacks> allocator,
-                                                      Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyShaderModule( m_device,
-                             static_cast<VkShaderModule>( shaderModule ),
-                             reinterpret_cast<const VkAllocationCallbacks *>(
-                               static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::ShaderModule                shaderModule,
-                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyShaderModule( m_device,
-                             static_cast<VkShaderModule>( shaderModule ),
-                             reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::ShaderModule  shaderModule,
-                                          Optional<const AllocationCallbacks> allocator,
-                                          Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyShaderModule( m_device,
-                             static_cast<VkShaderModule>( shaderModule ),
-                             reinterpret_cast<const VkAllocationCallbacks *>(
-                               static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroySwapchainKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR                swapchain,
-                                                      const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                                      Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroySwapchainKHR( m_device,
-                             static_cast<VkSwapchainKHR>( swapchain ),
-                             reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroySwapchainKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR  swapchain,
-                                                      Optional<const AllocationCallbacks> allocator,
-                                                      Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroySwapchainKHR( m_device,
-                             static_cast<VkSwapchainKHR>( swapchain ),
-                             reinterpret_cast<const VkAllocationCallbacks *>(
-                               static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::SwapchainKHR                swapchain,
-                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroySwapchainKHR( m_device,
-                             static_cast<VkSwapchainKHR>( swapchain ),
-                             reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::SwapchainKHR  swapchain,
-                                          Optional<const AllocationCallbacks> allocator,
-                                          Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroySwapchainKHR( m_device,
-                             static_cast<VkSwapchainKHR>( swapchain ),
-                             reinterpret_cast<const VkAllocationCallbacks *>(
-                               static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    Device::destroyValidationCacheEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT          validationCache,
-                                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                       Dispatch const &                                  d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyValidationCacheEXT( m_device,
-                                   static_cast<VkValidationCacheEXT>( validationCache ),
-                                   reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyValidationCacheEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache,
-                                                            Optional<const AllocationCallbacks>      allocator,
-                                                            Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyValidationCacheEXT( m_device,
-                                   static_cast<VkValidationCacheEXT>( validationCache ),
-                                   reinterpret_cast<const VkAllocationCallbacks *>(
-                                     static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::ValidationCacheEXT          validationCache,
-                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyValidationCacheEXT( m_device,
-                                   static_cast<VkValidationCacheEXT>( validationCache ),
-                                   reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache,
-                                          Optional<const AllocationCallbacks>      allocator,
-                                          Dispatch const &                         d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyValidationCacheEXT( m_device,
-                                   static_cast<VkValidationCacheEXT>( validationCache ),
-                                   reinterpret_cast<const VkAllocationCallbacks *>(
-                                     static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#if defined( VK_ENABLE_BETA_EXTENSIONS )
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyVideoSessionKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR             videoSession,
-                                                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                                         Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyVideoSessionKHR( m_device,
-                                static_cast<VkVideoSessionKHR>( videoSession ),
-                                reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyVideoSessionKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession,
-                                                         Optional<const AllocationCallbacks>   allocator,
-                                                         Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyVideoSessionKHR( m_device,
-                                static_cast<VkVideoSessionKHR>( videoSession ),
-                                reinterpret_cast<const VkAllocationCallbacks *>(
-                                  static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_ENABLE_BETA_EXTENSIONS*/
-
-#if defined( VK_ENABLE_BETA_EXTENSIONS )
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::VideoSessionKHR             videoSession,
-                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyVideoSessionKHR( m_device,
-                                static_cast<VkVideoSessionKHR>( videoSession ),
-                                reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession,
-                                          Optional<const AllocationCallbacks>   allocator,
-                                          Dispatch const &                      d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyVideoSessionKHR( m_device,
-                                static_cast<VkVideoSessionKHR>( videoSession ),
-                                reinterpret_cast<const VkAllocationCallbacks *>(
-                                  static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_ENABLE_BETA_EXTENSIONS*/
-
-#if defined( VK_ENABLE_BETA_EXTENSIONS )
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    Device::destroyVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR   videoSessionParameters,
-                                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                              Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyVideoSessionParametersKHR( m_device,
-                                          static_cast<VkVideoSessionParametersKHR>( videoSessionParameters ),
-                                          reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    Device::destroyVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters,
-                                              Optional<const AllocationCallbacks>             allocator,
-                                              Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyVideoSessionParametersKHR(
-      m_device,
-      static_cast<VkVideoSessionParametersKHR>( videoSessionParameters ),
-      reinterpret_cast<const VkAllocationCallbacks *>(
-        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_ENABLE_BETA_EXTENSIONS*/
-
-#if defined( VK_ENABLE_BETA_EXTENSIONS )
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR   videoSessionParameters,
-                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyVideoSessionParametersKHR( m_device,
-                                          static_cast<VkVideoSessionParametersKHR>( videoSessionParameters ),
-                                          reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters,
-                                          Optional<const AllocationCallbacks>             allocator,
-                                          Dispatch const &                                d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyVideoSessionParametersKHR(
-      m_device,
-      static_cast<VkVideoSessionParametersKHR>( videoSessionParameters ),
-      reinterpret_cast<const VkAllocationCallbacks *>(
-        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_ENABLE_BETA_EXTENSIONS*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::waitIdle( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkDeviceWaitIdle( m_device ) );
-  }
-#else
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
-    Device::waitIdle( Dispatch const & d ) const
-  {
-    Result result = static_cast<Result>( d.vkDeviceWaitIdle( m_device ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::waitIdle" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::displayPowerControlEXT( VULKAN_HPP_NAMESPACE::DisplayKHR                  display,
-                                    const VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT * pDisplayPowerInfo,
-                                    Dispatch const &                                  d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkDisplayPowerControlEXT( m_device,
-                                  static_cast<VkDisplayKHR>( display ),
-                                  reinterpret_cast<const VkDisplayPowerInfoEXT *>( pDisplayPowerInfo ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::displayPowerControlEXT(
-    VULKAN_HPP_NAMESPACE::DisplayKHR display, const DisplayPowerInfoEXT & displayPowerInfo, Dispatch const & d ) const
-  {
-    Result result = static_cast<Result>(
-      d.vkDisplayPowerControlEXT( m_device,
-                                  static_cast<VkDisplayKHR>( display ),
-                                  reinterpret_cast<const VkDisplayPowerInfoEXT *>( &displayPowerInfo ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::displayPowerControlEXT" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::flushMappedMemoryRanges( uint32_t                                        memoryRangeCount,
-                                     const VULKAN_HPP_NAMESPACE::MappedMemoryRange * pMemoryRanges,
-                                     Dispatch const &                                d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkFlushMappedMemoryRanges(
-      m_device, memoryRangeCount, reinterpret_cast<const VkMappedMemoryRange *>( pMemoryRanges ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
-    Device::flushMappedMemoryRanges( ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges,
-                                     Dispatch const &                                                  d ) const
-  {
-    Result result = static_cast<Result>( d.vkFlushMappedMemoryRanges(
-      m_device, memoryRanges.size(), reinterpret_cast<const VkMappedMemoryRange *>( memoryRanges.data() ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::flushMappedMemoryRanges" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::freeCommandBuffers( VULKAN_HPP_NAMESPACE::CommandPool           commandPool,
-                                                     uint32_t                                    commandBufferCount,
-                                                     const VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers,
-                                                     Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkFreeCommandBuffers( m_device,
-                            static_cast<VkCommandPool>( commandPool ),
-                            commandBufferCount,
-                            reinterpret_cast<const VkCommandBuffer *>( pCommandBuffers ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    Device::freeCommandBuffers( VULKAN_HPP_NAMESPACE::CommandPool                             commandPool,
-                                ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers,
-                                Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkFreeCommandBuffers( m_device,
-                            static_cast<VkCommandPool>( commandPool ),
-                            commandBuffers.size(),
-                            reinterpret_cast<const VkCommandBuffer *>( commandBuffers.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::free( VULKAN_HPP_NAMESPACE::CommandPool           commandPool,
-                                       uint32_t                                    commandBufferCount,
-                                       const VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers,
-                                       Dispatch const &                            d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkFreeCommandBuffers( m_device,
-                            static_cast<VkCommandPool>( commandPool ),
-                            commandBufferCount,
-                            reinterpret_cast<const VkCommandBuffer *>( pCommandBuffers ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::free( VULKAN_HPP_NAMESPACE::CommandPool                             commandPool,
-                                       ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers,
-                                       Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkFreeCommandBuffers( m_device,
-                            static_cast<VkCommandPool>( commandPool ),
-                            commandBuffers.size(),
-                            reinterpret_cast<const VkCommandBuffer *>( commandBuffers.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::freeDescriptorSets( VULKAN_HPP_NAMESPACE::DescriptorPool        descriptorPool,
-                                                       uint32_t                                    descriptorSetCount,
-                                                       const VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets,
-                                                       Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkFreeDescriptorSets( m_device,
-                              static_cast<VkDescriptorPool>( descriptorPool ),
-                              descriptorSetCount,
-                              reinterpret_cast<const VkDescriptorSet *>( pDescriptorSets ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<void>::type
-    Device::freeDescriptorSets( VULKAN_HPP_NAMESPACE::DescriptorPool                          descriptorPool,
-                                ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets,
-                                Dispatch const &                                              d ) const
-  {
-    Result result = static_cast<Result>(
-      d.vkFreeDescriptorSets( m_device,
-                              static_cast<VkDescriptorPool>( descriptorPool ),
-                              descriptorSets.size(),
-                              reinterpret_cast<const VkDescriptorSet *>( descriptorSets.data() ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::freeDescriptorSets" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::free( VULKAN_HPP_NAMESPACE::DescriptorPool        descriptorPool,
-                                         uint32_t                                    descriptorSetCount,
-                                         const VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets,
-                                         Dispatch const &                            d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkFreeDescriptorSets( m_device,
-                              static_cast<VkDescriptorPool>( descriptorPool ),
-                              descriptorSetCount,
-                              reinterpret_cast<const VkDescriptorSet *>( pDescriptorSets ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<void>::type
-    Device::free( VULKAN_HPP_NAMESPACE::DescriptorPool                          descriptorPool,
-                  ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets,
-                  Dispatch const &                                              d ) const
-  {
-    Result result = static_cast<Result>(
-      d.vkFreeDescriptorSets( m_device,
-                              static_cast<VkDescriptorPool>( descriptorPool ),
-                              descriptorSets.size(),
-                              reinterpret_cast<const VkDescriptorSet *>( descriptorSets.data() ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::free" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::freeMemory( VULKAN_HPP_NAMESPACE::DeviceMemory                memory,
-                                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                             Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkFreeMemory(
-      m_device, static_cast<VkDeviceMemory>( memory ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::freeMemory( VULKAN_HPP_NAMESPACE::DeviceMemory  memory,
-                                             Optional<const AllocationCallbacks> allocator,
-                                             Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkFreeMemory( m_device,
-                    static_cast<VkDeviceMemory>( memory ),
-                    reinterpret_cast<const VkAllocationCallbacks *>(
-                      static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::free( VULKAN_HPP_NAMESPACE::DeviceMemory                memory,
-                                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                       Dispatch const &                                  d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkFreeMemory(
-      m_device, static_cast<VkDeviceMemory>( memory ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::free( VULKAN_HPP_NAMESPACE::DeviceMemory  memory,
-                                       Optional<const AllocationCallbacks> allocator,
-                                       Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkFreeMemory( m_device,
-                    static_cast<VkDeviceMemory>( memory ),
-                    reinterpret_cast<const VkAllocationCallbacks *>(
-                      static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::getAccelerationStructureBuildSizesKHR(
-    VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR                 buildType,
-    const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR * pBuildInfo,
-    const uint32_t *                                                        pMaxPrimitiveCounts,
-    VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR *          pSizeInfo,
-    Dispatch const &                                                        d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkGetAccelerationStructureBuildSizesKHR(
-      m_device,
-      static_cast<VkAccelerationStructureBuildTypeKHR>( buildType ),
-      reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( pBuildInfo ),
-      pMaxPrimitiveCounts,
-      reinterpret_cast<VkAccelerationStructureBuildSizesInfoKHR *>( pSizeInfo ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR
-    Device::getAccelerationStructureBuildSizesKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType,
-                                                   const AccelerationStructureBuildGeometryInfoKHR &       buildInfo,
-                                                   ArrayProxy<const uint32_t> const & maxPrimitiveCounts,
-                                                   Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
-  {
-#  ifdef VULKAN_HPP_NO_EXCEPTIONS
-    VULKAN_HPP_ASSERT( maxPrimitiveCounts.size() == buildInfo.geometryCount );
-#  else
-    if ( maxPrimitiveCounts.size() != buildInfo.geometryCount )
-    {
-      throw LogicError(
-        VULKAN_HPP_NAMESPACE_STRING
-        "::Device::getAccelerationStructureBuildSizesKHR: maxPrimitiveCounts.size() != buildInfo.geometryCount" );
-    }
-#  endif /*VULKAN_HPP_NO_EXCEPTIONS*/
-    VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR sizeInfo;
-    d.vkGetAccelerationStructureBuildSizesKHR(
-      m_device,
-      static_cast<VkAccelerationStructureBuildTypeKHR>( buildType ),
-      reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( &buildInfo ),
-      maxPrimitiveCounts.data(),
-      reinterpret_cast<VkAccelerationStructureBuildSizesInfoKHR *>( &sizeInfo ) );
-    return sizeInfo;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE DeviceAddress Device::getAccelerationStructureAddressKHR(
-    const VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR * pInfo,
-    Dispatch const &                                                        d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<DeviceAddress>( d.vkGetAccelerationStructureDeviceAddressKHR(
-      m_device, reinterpret_cast<const VkAccelerationStructureDeviceAddressInfoKHR *>( pInfo ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE DeviceAddress Device::getAccelerationStructureAddressKHR(
-    const AccelerationStructureDeviceAddressInfoKHR & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return d.vkGetAccelerationStructureDeviceAddressKHR(
-      m_device, reinterpret_cast<const VkAccelerationStructureDeviceAddressInfoKHR *>( &info ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
-                                              size_t                                        dataSize,
-                                              void *                                        pData,
-                                              Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkGetAccelerationStructureHandleNV(
-      m_device, static_cast<VkAccelerationStructureNV>( accelerationStructure ), dataSize, pData ) );
+    Device::getRayTracingShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
+                                                uint32_t                       firstGroup,
+                                                uint32_t                       groupCount,
+                                                size_t                         dataSize,
+                                                void *                         pData,
+                                                Dispatch const &               d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesKHR(
+      m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, dataSize, pData ) );
   }
 
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename T, typename Dispatch>
   VULKAN_HPP_DEPRECATED( "This function is deprecated. Use one of the other flavours of it." )
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<void>::type Device::getAccelerationStructureHandleNV(
-      VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
-      ArrayProxy<T> const &                         data,
-      Dispatch const &                              d ) const
+    typename ResultValueType<void>::type Device::getRayTracingShaderGroupHandlesKHR(
+      VULKAN_HPP_NAMESPACE::Pipeline pipeline,
+      uint32_t                       firstGroup,
+      uint32_t                       groupCount,
+      ArrayProxy<T> const &          data,
+      Dispatch const &               d ) const
   {
-    Result result = static_cast<Result>(
-      d.vkGetAccelerationStructureHandleNV( m_device,
-                                            static_cast<VkAccelerationStructureNV>( accelerationStructure ),
-                                            data.size() * sizeof( T ),
-                                            reinterpret_cast<void *>( data.data() ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getAccelerationStructureHandleNV" );
+    Result result =
+      static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesKHR( m_device,
+                                                                   static_cast<VkPipeline>( pipeline ),
+                                                                   firstGroup,
+                                                                   groupCount,
+                                                                   data.size() * sizeof( T ),
+                                                                   reinterpret_cast<void *>( data.data() ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandlesKHR" );
   }
 
   template <typename T, typename Allocator, typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<std::vector<T, Allocator>>::type
-    Device::getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
-                                              size_t                                        dataSize,
-                                              Dispatch const &                              d ) const
+    Device::getRayTracingShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
+                                                uint32_t                       firstGroup,
+                                                uint32_t                       groupCount,
+                                                size_t                         dataSize,
+                                                Dispatch const &               d ) const
   {
     VULKAN_HPP_ASSERT( dataSize % sizeof( T ) == 0 );
     std::vector<T, Allocator> data( dataSize / sizeof( T ) );
-    Result                    result = static_cast<Result>(
-      d.vkGetAccelerationStructureHandleNV( m_device,
-                                            static_cast<VkAccelerationStructureNV>( accelerationStructure ),
-                                            data.size() * sizeof( T ),
-                                            reinterpret_cast<void *>( data.data() ) ) );
-    return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getAccelerationStructureHandleNV" );
+    Result                    result =
+      static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesKHR( m_device,
+                                                                   static_cast<VkPipeline>( pipeline ),
+                                                                   firstGroup,
+                                                                   groupCount,
+                                                                   data.size() * sizeof( T ),
+                                                                   reinterpret_cast<void *>( data.data() ) ) );
+    return createResultValue(
+      result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandlesKHR" );
   }
 
   template <typename T, typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<T>::type
-    Device::getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
-                                              Dispatch const &                              d ) const
+    Device::getRayTracingShaderGroupHandleKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
+                                               uint32_t                       firstGroup,
+                                               uint32_t                       groupCount,
+                                               Dispatch const &               d ) const
   {
     T      data;
-    Result result = static_cast<Result>(
-      d.vkGetAccelerationStructureHandleNV( m_device,
-                                            static_cast<VkAccelerationStructureNV>( accelerationStructure ),
-                                            sizeof( T ),
-                                            reinterpret_cast<void *>( &data ) ) );
-    return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getAccelerationStructureHandleNV" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::getAccelerationStructureMemoryRequirementsNV(
-    const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV * pInfo,
-    VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR *                              pMemoryRequirements,
-    Dispatch const &                                                            d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkGetAccelerationStructureMemoryRequirementsNV(
-      m_device,
-      reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoNV *>( pInfo ),
-      reinterpret_cast<VkMemoryRequirements2KHR *>( pMemoryRequirements ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR
-    Device::getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV & info,
-                                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR memoryRequirements;
-    d.vkGetAccelerationStructureMemoryRequirementsNV(
-      m_device,
-      reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoNV *>( &info ),
-      reinterpret_cast<VkMemoryRequirements2KHR *>( &memoryRequirements ) );
-    return memoryRequirements;
-  }
-
-  template <typename X, typename Y, typename... Z, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
-    Device::getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV & info,
-                                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    StructureChain<X, Y, Z...>                     structureChain;
-    VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR & memoryRequirements =
-      structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR>();
-    d.vkGetAccelerationStructureMemoryRequirementsNV(
-      m_device,
-      reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoNV *>( &info ),
-      reinterpret_cast<VkMemoryRequirements2KHR *>( &memoryRequirements ) );
-    return structureChain;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#if defined( VK_USE_PLATFORM_ANDROID_KHR )
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getAndroidHardwareBufferPropertiesANDROID(
-    const struct AHardwareBuffer *                                 buffer,
-    VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID * pProperties,
-    Dispatch const &                                               d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkGetAndroidHardwareBufferPropertiesANDROID(
-      m_device, buffer, reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID *>( pProperties ) ) );
-  }
-
-#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID>::type
-    Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const & d ) const
-  {
-    VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID properties;
-    Result result = static_cast<Result>( d.vkGetAndroidHardwareBufferPropertiesANDROID(
-      m_device, &buffer, reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID *>( &properties ) ) );
-    return createResultValue(
-      result, properties, VULKAN_HPP_NAMESPACE_STRING "::Device::getAndroidHardwareBufferPropertiesANDROID" );
-  }
-
-  template <typename X, typename Y, typename... Z, typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<StructureChain<X, Y, Z...>>::type
-    Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const & d ) const
-  {
-    StructureChain<X, Y, Z...>                                     structureChain;
-    VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID & properties =
-      structureChain.template get<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID>();
-    Result result = static_cast<Result>( d.vkGetAndroidHardwareBufferPropertiesANDROID(
-      m_device, &buffer, reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID *>( &properties ) ) );
-    return createResultValue(
-      result, structureChain, VULKAN_HPP_NAMESPACE_STRING "::Device::getAndroidHardwareBufferPropertiesANDROID" );
-  }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_USE_PLATFORM_ANDROID_KHR*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,
-                                                            Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<DeviceAddress>(
-      d.vkGetBufferDeviceAddress( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo *>( pInfo ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddress( const BufferDeviceAddressInfo & info,
-                                                            Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return d.vkGetBufferDeviceAddress( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddressEXT(
-    const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<DeviceAddress>(
-      d.vkGetBufferDeviceAddressEXT( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo *>( pInfo ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddressEXT( const BufferDeviceAddressInfo & info,
-                                                               Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return d.vkGetBufferDeviceAddressEXT( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddressKHR(
-    const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<DeviceAddress>(
-      d.vkGetBufferDeviceAddressKHR( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo *>( pInfo ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddressKHR( const BufferDeviceAddressInfo & info,
-                                                               Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return d.vkGetBufferDeviceAddressKHR( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    Device::getBufferMemoryRequirements( VULKAN_HPP_NAMESPACE::Buffer               buffer,
-                                         VULKAN_HPP_NAMESPACE::MemoryRequirements * pMemoryRequirements,
-                                         Dispatch const &                           d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkGetBufferMemoryRequirements(
-      m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<VkMemoryRequirements *>( pMemoryRequirements ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements
-                                         Device::getBufferMemoryRequirements( VULKAN_HPP_NAMESPACE::Buffer buffer,
-                                         Dispatch const &             d ) const VULKAN_HPP_NOEXCEPT
-  {
-    VULKAN_HPP_NAMESPACE::MemoryRequirements memoryRequirements;
-    d.vkGetBufferMemoryRequirements(
-      m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<VkMemoryRequirements *>( &memoryRequirements ) );
-    return memoryRequirements;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    Device::getBufferMemoryRequirements2( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 * pInfo,
-                                          VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements,
-                                          Dispatch const &                            d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkGetBufferMemoryRequirements2( m_device,
-                                      reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( pInfo ),
-                                      reinterpret_cast<VkMemoryRequirements2 *>( pMemoryRequirements ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2
-    Device::getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info,
-                                          Dispatch const &                      d ) const VULKAN_HPP_NOEXCEPT
-  {
-    VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements;
-    d.vkGetBufferMemoryRequirements2( m_device,
-                                      reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( &info ),
-                                      reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
-    return memoryRequirements;
-  }
-
-  template <typename X, typename Y, typename... Z, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
-    Device::getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info,
-                                          Dispatch const &                      d ) const VULKAN_HPP_NOEXCEPT
-  {
-    StructureChain<X, Y, Z...>                  structureChain;
-    VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements =
-      structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>();
-    d.vkGetBufferMemoryRequirements2( m_device,
-                                      reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( &info ),
-                                      reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
-    return structureChain;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    Device::getBufferMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 * pInfo,
-                                             VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements,
-                                             Dispatch const &                            d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkGetBufferMemoryRequirements2KHR( m_device,
-                                         reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( pInfo ),
-                                         reinterpret_cast<VkMemoryRequirements2 *>( pMemoryRequirements ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2
-    Device::getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info,
-                                             Dispatch const &                      d ) const VULKAN_HPP_NOEXCEPT
-  {
-    VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements;
-    d.vkGetBufferMemoryRequirements2KHR( m_device,
-                                         reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( &info ),
-                                         reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
-    return memoryRequirements;
-  }
-
-  template <typename X, typename Y, typename... Z, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
-    Device::getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info,
-                                             Dispatch const &                      d ) const VULKAN_HPP_NOEXCEPT
-  {
-    StructureChain<X, Y, Z...>                  structureChain;
-    VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements =
-      structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>();
-    d.vkGetBufferMemoryRequirements2KHR( m_device,
-                                         reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( &info ),
-                                         reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
-    return structureChain;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE uint64_t Device::getBufferOpaqueCaptureAddress(
-    const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return d.vkGetBufferOpaqueCaptureAddress( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo *>( pInfo ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE uint64_t Device::getBufferOpaqueCaptureAddress( const BufferDeviceAddressInfo & info,
-                                                                    Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return d.vkGetBufferOpaqueCaptureAddress( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE uint64_t Device::getBufferOpaqueCaptureAddressKHR(
-    const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return d.vkGetBufferOpaqueCaptureAddressKHR( m_device,
-                                                 reinterpret_cast<const VkBufferDeviceAddressInfo *>( pInfo ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE uint64_t Device::getBufferOpaqueCaptureAddressKHR( const BufferDeviceAddressInfo & info,
-                                                                       Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return d.vkGetBufferOpaqueCaptureAddressKHR( m_device,
-                                                 reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::getCalibratedTimestampsEXT( uint32_t                                                 timestampCount,
-                                        const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT * pTimestampInfos,
-                                        uint64_t *                                               pTimestamps,
-                                        uint64_t *                                               pMaxDeviation,
-                                        Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkGetCalibratedTimestampsEXT( m_device,
-                                      timestampCount,
-                                      reinterpret_cast<const VkCalibratedTimestampInfoEXT *>( pTimestampInfos ),
-                                      pTimestamps,
-                                      pMaxDeviation ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_DEPRECATED( "This function is deprecated. Use one of the other flavours of it." )
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<uint64_t>::type Device::getCalibratedTimestampsEXT(
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT> const & timestampInfos,
-      ArrayProxy<uint64_t> const &                                               timestamps,
-      Dispatch const &                                                           d ) const
-  {
-#  ifdef VULKAN_HPP_NO_EXCEPTIONS
-    VULKAN_HPP_ASSERT( timestampInfos.size() == timestamps.size() );
-#  else
-    if ( timestampInfos.size() != timestamps.size() )
-    {
-      throw LogicError( VULKAN_HPP_NAMESPACE_STRING
-                        "::VkDevice::getCalibratedTimestampsEXT: timestampInfos.size() != timestamps.size()" );
-    }
-#  endif /*VULKAN_HPP_NO_EXCEPTIONS*/
-    uint64_t maxDeviation;
-    Result   result = static_cast<Result>(
-      d.vkGetCalibratedTimestampsEXT( m_device,
-                                      timestampInfos.size(),
-                                      reinterpret_cast<const VkCalibratedTimestampInfoEXT *>( timestampInfos.data() ),
-                                      timestamps.data(),
-                                      &maxDeviation ) );
-    return createResultValue(
-      result, maxDeviation, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsEXT" );
-  }
-
-  template <typename Uint64_tAllocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type
-    Device::getCalibratedTimestampsEXT(
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT> const & timestampInfos,
-      Dispatch const &                                                           d ) const
-  {
-    std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t> data(
-      std::piecewise_construct, std::forward_as_tuple( timestampInfos.size() ), std::forward_as_tuple( 0 ) );
-    std::vector<uint64_t, Uint64_tAllocator> & timestamps   = data.first;
-    uint64_t &                                 maxDeviation = data.second;
-    Result                                     result       = static_cast<Result>(
-      d.vkGetCalibratedTimestampsEXT( m_device,
-                                      timestampInfos.size(),
-                                      reinterpret_cast<const VkCalibratedTimestampInfoEXT *>( timestampInfos.data() ),
-                                      timestamps.data(),
-                                      &maxDeviation ) );
-    return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsEXT" );
-  }
-
-  template <typename Uint64_tAllocator,
-            typename Dispatch,
-            typename B,
-            typename std::enable_if<std::is_same<typename B::value_type, uint64_t>::value, int>::type>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type
-    Device::getCalibratedTimestampsEXT(
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT> const & timestampInfos,
-      Uint64_tAllocator &                                                        uint64_tAllocator,
-      Dispatch const &                                                           d ) const
-  {
-    std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t> data(
-      std::piecewise_construct,
-      std::forward_as_tuple( timestampInfos.size(), uint64_tAllocator ),
-      std::forward_as_tuple( 0 ) );
-    std::vector<uint64_t, Uint64_tAllocator> & timestamps   = data.first;
-    uint64_t &                                 maxDeviation = data.second;
-    Result                                     result       = static_cast<Result>(
-      d.vkGetCalibratedTimestampsEXT( m_device,
-                                      timestampInfos.size(),
-                                      reinterpret_cast<const VkCalibratedTimestampInfoEXT *>( timestampInfos.data() ),
-                                      timestamps.data(),
-                                      &maxDeviation ) );
-    return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsEXT" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE uint32_t Device::getDeferredOperationMaxConcurrencyKHR(
-    VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return d.vkGetDeferredOperationMaxConcurrencyKHR( m_device, static_cast<VkDeferredOperationKHR>( operation ) );
-  }
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getDeferredOperationResultKHR(
-    VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkGetDeferredOperationResultKHR( m_device, static_cast<VkDeferredOperationKHR>( operation ) ) );
-  }
-#else
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getDeferredOperationResultKHR(
-    VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, Dispatch const & d ) const
-  {
-    Result result = static_cast<Result>(
-      d.vkGetDeferredOperationResultKHR( m_device, static_cast<VkDeferredOperationKHR>( operation ) ) );
-    return createResultValue( result,
-                              VULKAN_HPP_NAMESPACE_STRING "::Device::getDeferredOperationResultKHR",
-                              { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eNotReady } );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    Device::getDescriptorSetLayoutSupport( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo * pCreateInfo,
-                                           VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport *          pSupport,
-                                           Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkGetDescriptorSetLayoutSupport( m_device,
-                                       reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( pCreateInfo ),
-                                       reinterpret_cast<VkDescriptorSetLayoutSupport *>( pSupport ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport
-    Device::getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo,
-                                           Dispatch const &                      d ) const VULKAN_HPP_NOEXCEPT
-  {
-    VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport support;
-    d.vkGetDescriptorSetLayoutSupport( m_device,
-                                       reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ),
-                                       reinterpret_cast<VkDescriptorSetLayoutSupport *>( &support ) );
-    return support;
-  }
-
-  template <typename X, typename Y, typename... Z, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
-    Device::getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo,
-                                           Dispatch const &                      d ) const VULKAN_HPP_NOEXCEPT
-  {
-    StructureChain<X, Y, Z...>                         structureChain;
-    VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport & support =
-      structureChain.template get<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport>();
-    d.vkGetDescriptorSetLayoutSupport( m_device,
-                                       reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ),
-                                       reinterpret_cast<VkDescriptorSetLayoutSupport *>( &support ) );
-    return structureChain;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    Device::getDescriptorSetLayoutSupportKHR( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo * pCreateInfo,
-                                              VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport *          pSupport,
-                                              Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkGetDescriptorSetLayoutSupportKHR( m_device,
-                                          reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( pCreateInfo ),
-                                          reinterpret_cast<VkDescriptorSetLayoutSupport *>( pSupport ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport
-    Device::getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo,
-                                              Dispatch const &                      d ) const VULKAN_HPP_NOEXCEPT
-  {
-    VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport support;
-    d.vkGetDescriptorSetLayoutSupportKHR( m_device,
-                                          reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ),
-                                          reinterpret_cast<VkDescriptorSetLayoutSupport *>( &support ) );
-    return support;
-  }
-
-  template <typename X, typename Y, typename... Z, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
-    Device::getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo,
-                                              Dispatch const &                      d ) const VULKAN_HPP_NOEXCEPT
-  {
-    StructureChain<X, Y, Z...>                         structureChain;
-    VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport & support =
-      structureChain.template get<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport>();
-    d.vkGetDescriptorSetLayoutSupportKHR( m_device,
-                                          reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ),
-                                          reinterpret_cast<VkDescriptorSetLayoutSupport *>( &support ) );
-    return structureChain;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::getAccelerationStructureCompatibilityKHR(
-    const VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR * pVersionInfo,
-    VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR *     pCompatibility,
-    Dispatch const &                                                  d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkGetDeviceAccelerationStructureCompatibilityKHR(
-      m_device,
-      reinterpret_cast<const VkAccelerationStructureVersionInfoKHR *>( pVersionInfo ),
-      reinterpret_cast<VkAccelerationStructureCompatibilityKHR *>( pCompatibility ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR
-    Device::getAccelerationStructureCompatibilityKHR( const AccelerationStructureVersionInfoKHR & versionInfo,
-                                                      Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR compatibility;
-    d.vkGetDeviceAccelerationStructureCompatibilityKHR(
-      m_device,
-      reinterpret_cast<const VkAccelerationStructureVersionInfoKHR *>( &versionInfo ),
-      reinterpret_cast<VkAccelerationStructureCompatibilityKHR *>( &compatibility ) );
-    return compatibility;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    Device::getGroupPeerMemoryFeatures( uint32_t                                       heapIndex,
-                                        uint32_t                                       localDeviceIndex,
-                                        uint32_t                                       remoteDeviceIndex,
-                                        VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags * pPeerMemoryFeatures,
-                                        Dispatch const &                               d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkGetDeviceGroupPeerMemoryFeatures( m_device,
-                                          heapIndex,
-                                          localDeviceIndex,
-                                          remoteDeviceIndex,
-                                          reinterpret_cast<VkPeerMemoryFeatureFlags *>( pPeerMemoryFeatures ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags
-                                         Device::getGroupPeerMemoryFeatures( uint32_t         heapIndex,
-                                        uint32_t         localDeviceIndex,
-                                        uint32_t         remoteDeviceIndex,
-                                        Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags peerMemoryFeatures;
-    d.vkGetDeviceGroupPeerMemoryFeatures( m_device,
-                                          heapIndex,
-                                          localDeviceIndex,
-                                          remoteDeviceIndex,
-                                          reinterpret_cast<VkPeerMemoryFeatureFlags *>( &peerMemoryFeatures ) );
-    return peerMemoryFeatures;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    Device::getGroupPeerMemoryFeaturesKHR( uint32_t                                       heapIndex,
-                                           uint32_t                                       localDeviceIndex,
-                                           uint32_t                                       remoteDeviceIndex,
-                                           VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags * pPeerMemoryFeatures,
-                                           Dispatch const &                               d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkGetDeviceGroupPeerMemoryFeaturesKHR( m_device,
-                                             heapIndex,
-                                             localDeviceIndex,
-                                             remoteDeviceIndex,
-                                             reinterpret_cast<VkPeerMemoryFeatureFlags *>( pPeerMemoryFeatures ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags
-                                         Device::getGroupPeerMemoryFeaturesKHR( uint32_t         heapIndex,
-                                           uint32_t         localDeviceIndex,
-                                           uint32_t         remoteDeviceIndex,
-                                           Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags peerMemoryFeatures;
-    d.vkGetDeviceGroupPeerMemoryFeaturesKHR( m_device,
-                                             heapIndex,
-                                             localDeviceIndex,
-                                             remoteDeviceIndex,
-                                             reinterpret_cast<VkPeerMemoryFeatureFlags *>( &peerMemoryFeatures ) );
-    return peerMemoryFeatures;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getGroupPresentCapabilitiesKHR(
-    VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR * pDeviceGroupPresentCapabilities,
-    Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkGetDeviceGroupPresentCapabilitiesKHR(
-      m_device, reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR *>( pDeviceGroupPresentCapabilities ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR>::type
-    Device::getGroupPresentCapabilitiesKHR( Dispatch const & d ) const
-  {
-    VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR deviceGroupPresentCapabilities;
-    Result result = static_cast<Result>( d.vkGetDeviceGroupPresentCapabilitiesKHR(
-      m_device, reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR *>( &deviceGroupPresentCapabilities ) ) );
-    return createResultValue(
-      result, deviceGroupPresentCapabilities, VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupPresentCapabilitiesKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#if defined( VK_USE_PLATFORM_WIN32_KHR )
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::getGroupSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
-                                             VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR *      pModes,
-                                             Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkGetDeviceGroupSurfacePresentModes2EXT(
-      m_device,
-      reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( pSurfaceInfo ),
-      reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR *>( pModes ) ) );
-  }
-
-#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR>::type
-    Device::getGroupSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
-                                             Dispatch const &                      d ) const
-  {
-    VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR modes;
-    Result result = static_cast<Result>( d.vkGetDeviceGroupSurfacePresentModes2EXT(
-      m_device,
-      reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
-      reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR *>( &modes ) ) );
-    return createResultValue( result, modes, VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupSurfacePresentModes2EXT" );
-  }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_USE_PLATFORM_WIN32_KHR*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::getGroupSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR                       surface,
-                                            VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR * pModes,
-                                            Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkGetDeviceGroupSurfacePresentModesKHR( m_device,
-                                                static_cast<VkSurfaceKHR>( surface ),
-                                                reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR *>( pModes ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR>::type
-    Device::getGroupSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d ) const
-  {
-    VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR modes;
-    Result                                               result = static_cast<Result>(
-      d.vkGetDeviceGroupSurfacePresentModesKHR( m_device,
-                                                static_cast<VkSurfaceKHR>( surface ),
-                                                reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR *>( &modes ) ) );
-    return createResultValue( result, modes, VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupSurfacePresentModesKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::getMemoryCommitment( VULKAN_HPP_NAMESPACE::DeviceMemory memory,
-                                                      VULKAN_HPP_NAMESPACE::DeviceSize * pCommittedMemoryInBytes,
-                                                      Dispatch const &                   d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkGetDeviceMemoryCommitment(
-      m_device, static_cast<VkDeviceMemory>( memory ), reinterpret_cast<VkDeviceSize *>( pCommittedMemoryInBytes ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceSize
-                                         Device::getMemoryCommitment( VULKAN_HPP_NAMESPACE::DeviceMemory memory,
-                                 Dispatch const &                   d ) const VULKAN_HPP_NOEXCEPT
-  {
-    VULKAN_HPP_NAMESPACE::DeviceSize committedMemoryInBytes;
-    d.vkGetDeviceMemoryCommitment(
-      m_device, static_cast<VkDeviceMemory>( memory ), reinterpret_cast<VkDeviceSize *>( &committedMemoryInBytes ) );
-    return committedMemoryInBytes;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE uint64_t
-    Device::getMemoryOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo * pInfo,
-                                           Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return d.vkGetDeviceMemoryOpaqueCaptureAddress(
-      m_device, reinterpret_cast<const VkDeviceMemoryOpaqueCaptureAddressInfo *>( pInfo ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE uint64_t Device::getMemoryOpaqueCaptureAddress( const DeviceMemoryOpaqueCaptureAddressInfo & info,
-                                                                    Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return d.vkGetDeviceMemoryOpaqueCaptureAddress(
-      m_device, reinterpret_cast<const VkDeviceMemoryOpaqueCaptureAddressInfo *>( &info ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE uint64_t
-    Device::getMemoryOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo * pInfo,
-                                              Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return d.vkGetDeviceMemoryOpaqueCaptureAddressKHR(
-      m_device, reinterpret_cast<const VkDeviceMemoryOpaqueCaptureAddressInfo *>( pInfo ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE uint64_t Device::getMemoryOpaqueCaptureAddressKHR(
-    const DeviceMemoryOpaqueCaptureAddressInfo & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return d.vkGetDeviceMemoryOpaqueCaptureAddressKHR(
-      m_device, reinterpret_cast<const VkDeviceMemoryOpaqueCaptureAddressInfo *>( &info ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE PFN_vkVoidFunction Device::getProcAddr( const char *     pName,
-                                                            Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return d.vkGetDeviceProcAddr( m_device, pName );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE PFN_vkVoidFunction Device::getProcAddr( const std::string & name,
-                                                            Dispatch const &    d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return d.vkGetDeviceProcAddr( m_device, name.c_str() );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::getQueue( uint32_t                      queueFamilyIndex,
-                                           uint32_t                      queueIndex,
-                                           VULKAN_HPP_NAMESPACE::Queue * pQueue,
-                                           Dispatch const &              d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkGetDeviceQueue( m_device, queueFamilyIndex, queueIndex, reinterpret_cast<VkQueue *>( pQueue ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Queue
-    Device::getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    VULKAN_HPP_NAMESPACE::Queue queue;
-    d.vkGetDeviceQueue( m_device, queueFamilyIndex, queueIndex, reinterpret_cast<VkQueue *>( &queue ) );
-    return queue;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::getQueue2( const VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 * pQueueInfo,
-                                            VULKAN_HPP_NAMESPACE::Queue *                  pQueue,
-                                            Dispatch const &                               d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkGetDeviceQueue2(
-      m_device, reinterpret_cast<const VkDeviceQueueInfo2 *>( pQueueInfo ), reinterpret_cast<VkQueue *>( pQueue ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Queue
-    Device::getQueue2( const DeviceQueueInfo2 & queueInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    VULKAN_HPP_NAMESPACE::Queue queue;
-    d.vkGetDeviceQueue2(
-      m_device, reinterpret_cast<const VkDeviceQueueInfo2 *>( &queueInfo ), reinterpret_cast<VkQueue *>( &queue ) );
-    return queue;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getEventStatus( VULKAN_HPP_NAMESPACE::Event event,
-                                                                        Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkGetEventStatus( m_device, static_cast<VkEvent>( event ) ) );
-  }
-#else
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getEventStatus( VULKAN_HPP_NAMESPACE::Event event,
-                                                                        Dispatch const & d ) const
-  {
-    Result result = static_cast<Result>( d.vkGetEventStatus( m_device, static_cast<VkEvent>( event ) ) );
-    return createResultValue( result,
-                              VULKAN_HPP_NAMESPACE_STRING "::Device::getEventStatus",
-                              { VULKAN_HPP_NAMESPACE::Result::eEventSet, VULKAN_HPP_NAMESPACE::Result::eEventReset } );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::getFenceFdKHR( const VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR * pGetFdInfo,
-                           int *                                           pFd,
-                           Dispatch const &                                d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkGetFenceFdKHR( m_device, reinterpret_cast<const VkFenceGetFdInfoKHR *>( pGetFdInfo ), pFd ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<int>::type
-    Device::getFenceFdKHR( const FenceGetFdInfoKHR & getFdInfo, Dispatch const & d ) const
-  {
-    int    fd;
-    Result result = static_cast<Result>(
-      d.vkGetFenceFdKHR( m_device, reinterpret_cast<const VkFenceGetFdInfoKHR *>( &getFdInfo ), &fd ) );
-    return createResultValue( result, fd, VULKAN_HPP_NAMESPACE_STRING "::Device::getFenceFdKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getFenceStatus( VULKAN_HPP_NAMESPACE::Fence fence,
-                                                                        Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkGetFenceStatus( m_device, static_cast<VkFence>( fence ) ) );
-  }
-#else
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getFenceStatus( VULKAN_HPP_NAMESPACE::Fence fence,
-                                                                        Dispatch const & d ) const
-  {
-    Result result = static_cast<Result>( d.vkGetFenceStatus( m_device, static_cast<VkFence>( fence ) ) );
-    return createResultValue( result,
-                              VULKAN_HPP_NAMESPACE_STRING "::Device::getFenceStatus",
-                              { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eNotReady } );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#if defined( VK_USE_PLATFORM_WIN32_KHR )
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::getFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR * pGetWin32HandleInfo,
-                                    HANDLE *                                                 pHandle,
-                                    Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkGetFenceWin32HandleKHR(
-      m_device, reinterpret_cast<const VkFenceGetWin32HandleInfoKHR *>( pGetWin32HandleInfo ), pHandle ) );
-  }
-
-#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<HANDLE>::type
-    Device::getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const & d ) const
-  {
-    HANDLE handle;
-    Result result = static_cast<Result>( d.vkGetFenceWin32HandleKHR(
-      m_device, reinterpret_cast<const VkFenceGetWin32HandleInfoKHR *>( &getWin32HandleInfo ), &handle ) );
-    return createResultValue( result, handle, VULKAN_HPP_NAMESPACE_STRING "::Device::getFenceWin32HandleKHR" );
-  }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_USE_PLATFORM_WIN32_KHR*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::getGeneratedCommandsMemoryRequirementsNV(
-    const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV * pInfo,
-    VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                             pMemoryRequirements,
-    Dispatch const &                                                        d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkGetGeneratedCommandsMemoryRequirementsNV(
-      m_device,
-      reinterpret_cast<const VkGeneratedCommandsMemoryRequirementsInfoNV *>( pInfo ),
-      reinterpret_cast<VkMemoryRequirements2 *>( pMemoryRequirements ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2
-    Device::getGeneratedCommandsMemoryRequirementsNV( const GeneratedCommandsMemoryRequirementsInfoNV & info,
-                                                      Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements;
-    d.vkGetGeneratedCommandsMemoryRequirementsNV(
-      m_device,
-      reinterpret_cast<const VkGeneratedCommandsMemoryRequirementsInfoNV *>( &info ),
-      reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
-    return memoryRequirements;
-  }
-
-  template <typename X, typename Y, typename... Z, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
-    Device::getGeneratedCommandsMemoryRequirementsNV( const GeneratedCommandsMemoryRequirementsInfoNV & info,
-                                                      Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    StructureChain<X, Y, Z...>                  structureChain;
-    VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements =
-      structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>();
-    d.vkGetGeneratedCommandsMemoryRequirementsNV(
-      m_device,
-      reinterpret_cast<const VkGeneratedCommandsMemoryRequirementsInfoNV *>( &info ),
-      reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
-    return structureChain;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getImageDrmFormatModifierPropertiesEXT(
-    VULKAN_HPP_NAMESPACE::Image                                 image,
-    VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT * pProperties,
-    Dispatch const &                                            d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkGetImageDrmFormatModifierPropertiesEXT(
-      m_device,
-      static_cast<VkImage>( image ),
-      reinterpret_cast<VkImageDrmFormatModifierPropertiesEXT *>( pProperties ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT>::type
-    Device::getImageDrmFormatModifierPropertiesEXT( VULKAN_HPP_NAMESPACE::Image image, Dispatch const & d ) const
-  {
-    VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT properties;
-    Result result = static_cast<Result>( d.vkGetImageDrmFormatModifierPropertiesEXT(
-      m_device,
-      static_cast<VkImage>( image ),
-      reinterpret_cast<VkImageDrmFormatModifierPropertiesEXT *>( &properties ) ) );
-    return createResultValue(
-      result, properties, VULKAN_HPP_NAMESPACE_STRING "::Device::getImageDrmFormatModifierPropertiesEXT" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    Device::getImageMemoryRequirements( VULKAN_HPP_NAMESPACE::Image                image,
-                                        VULKAN_HPP_NAMESPACE::MemoryRequirements * pMemoryRequirements,
-                                        Dispatch const &                           d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkGetImageMemoryRequirements(
-      m_device, static_cast<VkImage>( image ), reinterpret_cast<VkMemoryRequirements *>( pMemoryRequirements ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements
-                                         Device::getImageMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image,
-                                        Dispatch const &            d ) const VULKAN_HPP_NOEXCEPT
-  {
-    VULKAN_HPP_NAMESPACE::MemoryRequirements memoryRequirements;
-    d.vkGetImageMemoryRequirements(
-      m_device, static_cast<VkImage>( image ), reinterpret_cast<VkMemoryRequirements *>( &memoryRequirements ) );
-    return memoryRequirements;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    Device::getImageMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 * pInfo,
-                                         VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                pMemoryRequirements,
-                                         Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkGetImageMemoryRequirements2( m_device,
-                                     reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( pInfo ),
-                                     reinterpret_cast<VkMemoryRequirements2 *>( pMemoryRequirements ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2
-                                         Device::getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info,
-                                         Dispatch const &                     d ) const VULKAN_HPP_NOEXCEPT
-  {
-    VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements;
-    d.vkGetImageMemoryRequirements2( m_device,
-                                     reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( &info ),
-                                     reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
-    return memoryRequirements;
-  }
-
-  template <typename X, typename Y, typename... Z, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
-                                         Device::getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info,
-                                         Dispatch const &                     d ) const VULKAN_HPP_NOEXCEPT
-  {
-    StructureChain<X, Y, Z...>                  structureChain;
-    VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements =
-      structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>();
-    d.vkGetImageMemoryRequirements2( m_device,
-                                     reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( &info ),
-                                     reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
-    return structureChain;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    Device::getImageMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 * pInfo,
-                                            VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements,
-                                            Dispatch const &                            d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkGetImageMemoryRequirements2KHR( m_device,
-                                        reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( pInfo ),
-                                        reinterpret_cast<VkMemoryRequirements2 *>( pMemoryRequirements ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2
-    Device::getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info,
-                                            Dispatch const &                     d ) const VULKAN_HPP_NOEXCEPT
-  {
-    VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements;
-    d.vkGetImageMemoryRequirements2KHR( m_device,
-                                        reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( &info ),
-                                        reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
-    return memoryRequirements;
-  }
-
-  template <typename X, typename Y, typename... Z, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
-    Device::getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info,
-                                            Dispatch const &                     d ) const VULKAN_HPP_NOEXCEPT
-  {
-    StructureChain<X, Y, Z...>                  structureChain;
-    VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements =
-      structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>();
-    d.vkGetImageMemoryRequirements2KHR( m_device,
-                                        reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( &info ),
-                                        reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
-    return structureChain;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements(
-    VULKAN_HPP_NAMESPACE::Image                           image,
-    uint32_t *                                            pSparseMemoryRequirementCount,
-    VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements * pSparseMemoryRequirements,
-    Dispatch const &                                      d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkGetImageSparseMemoryRequirements(
-      m_device,
-      static_cast<VkImage>( image ),
-      pSparseMemoryRequirementCount,
-      reinterpret_cast<VkSparseImageMemoryRequirements *>( pSparseMemoryRequirements ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename SparseImageMemoryRequirementsAllocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD
-    VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator>
-    Device::getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image, Dispatch const & d ) const
-  {
-    std::vector<SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator> sparseMemoryRequirements;
-    uint32_t                                                                           sparseMemoryRequirementCount;
-    d.vkGetImageSparseMemoryRequirements(
-      m_device, static_cast<VkImage>( image ), &sparseMemoryRequirementCount, nullptr );
-    sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
-    d.vkGetImageSparseMemoryRequirements(
-      m_device,
-      static_cast<VkImage>( image ),
-      &sparseMemoryRequirementCount,
-      reinterpret_cast<VkSparseImageMemoryRequirements *>( sparseMemoryRequirements.data() ) );
-    VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() );
-    return sparseMemoryRequirements;
-  }
-
-  template <
-    typename SparseImageMemoryRequirementsAllocator,
-    typename Dispatch,
-    typename B,
-    typename std::enable_if<std::is_same<typename B::value_type, SparseImageMemoryRequirements>::value, int>::type>
-  VULKAN_HPP_NODISCARD
-    VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator>
-                      Device::getImageSparseMemoryRequirements(
-      VULKAN_HPP_NAMESPACE::Image              image,
-      SparseImageMemoryRequirementsAllocator & sparseImageMemoryRequirementsAllocator,
-      Dispatch const &                         d ) const
-  {
-    std::vector<SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator> sparseMemoryRequirements(
-      sparseImageMemoryRequirementsAllocator );
-    uint32_t sparseMemoryRequirementCount;
-    d.vkGetImageSparseMemoryRequirements(
-      m_device, static_cast<VkImage>( image ), &sparseMemoryRequirementCount, nullptr );
-    sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
-    d.vkGetImageSparseMemoryRequirements(
-      m_device,
-      static_cast<VkImage>( image ),
-      &sparseMemoryRequirementCount,
-      reinterpret_cast<VkSparseImageMemoryRequirements *>( sparseMemoryRequirements.data() ) );
-    VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() );
-    return sparseMemoryRequirements;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements2(
-    const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 * pInfo,
-    uint32_t *                                                       pSparseMemoryRequirementCount,
-    VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 *           pSparseMemoryRequirements,
-    Dispatch const &                                                 d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkGetImageSparseMemoryRequirements2(
-      m_device,
-      reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( pInfo ),
-      pSparseMemoryRequirementCount,
-      reinterpret_cast<VkSparseImageMemoryRequirements2 *>( pSparseMemoryRequirements ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename SparseImageMemoryRequirements2Allocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD
-    VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
-                      Device::getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info,
-                                               Dispatch const &                           d ) const
-  {
-    std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> sparseMemoryRequirements;
-    uint32_t                                                                             sparseMemoryRequirementCount;
-    d.vkGetImageSparseMemoryRequirements2( m_device,
-                                           reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ),
-                                           &sparseMemoryRequirementCount,
-                                           nullptr );
-    sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
-    d.vkGetImageSparseMemoryRequirements2(
-      m_device,
-      reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ),
-      &sparseMemoryRequirementCount,
-      reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) );
-    VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() );
-    return sparseMemoryRequirements;
-  }
-
-  template <
-    typename SparseImageMemoryRequirements2Allocator,
-    typename Dispatch,
-    typename B,
-    typename std::enable_if<std::is_same<typename B::value_type, SparseImageMemoryRequirements2>::value, int>::type>
-  VULKAN_HPP_NODISCARD
-    VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
-                      Device::getImageSparseMemoryRequirements2(
-      const ImageSparseMemoryRequirementsInfo2 & info,
-      SparseImageMemoryRequirements2Allocator &  sparseImageMemoryRequirements2Allocator,
-      Dispatch const &                           d ) const
-  {
-    std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> sparseMemoryRequirements(
-      sparseImageMemoryRequirements2Allocator );
-    uint32_t sparseMemoryRequirementCount;
-    d.vkGetImageSparseMemoryRequirements2( m_device,
-                                           reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ),
-                                           &sparseMemoryRequirementCount,
-                                           nullptr );
-    sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
-    d.vkGetImageSparseMemoryRequirements2(
-      m_device,
-      reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ),
-      &sparseMemoryRequirementCount,
-      reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) );
-    VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() );
-    return sparseMemoryRequirements;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements2KHR(
-    const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 * pInfo,
-    uint32_t *                                                       pSparseMemoryRequirementCount,
-    VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 *           pSparseMemoryRequirements,
-    Dispatch const &                                                 d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkGetImageSparseMemoryRequirements2KHR(
-      m_device,
-      reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( pInfo ),
-      pSparseMemoryRequirementCount,
-      reinterpret_cast<VkSparseImageMemoryRequirements2 *>( pSparseMemoryRequirements ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename SparseImageMemoryRequirements2Allocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD
-    VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
-                      Device::getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info,
-                                                  Dispatch const &                           d ) const
-  {
-    std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> sparseMemoryRequirements;
-    uint32_t                                                                             sparseMemoryRequirementCount;
-    d.vkGetImageSparseMemoryRequirements2KHR( m_device,
-                                              reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ),
-                                              &sparseMemoryRequirementCount,
-                                              nullptr );
-    sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
-    d.vkGetImageSparseMemoryRequirements2KHR(
-      m_device,
-      reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ),
-      &sparseMemoryRequirementCount,
-      reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) );
-    VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() );
-    return sparseMemoryRequirements;
-  }
-
-  template <
-    typename SparseImageMemoryRequirements2Allocator,
-    typename Dispatch,
-    typename B,
-    typename std::enable_if<std::is_same<typename B::value_type, SparseImageMemoryRequirements2>::value, int>::type>
-  VULKAN_HPP_NODISCARD
-    VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
-                      Device::getImageSparseMemoryRequirements2KHR(
-      const ImageSparseMemoryRequirementsInfo2 & info,
-      SparseImageMemoryRequirements2Allocator &  sparseImageMemoryRequirements2Allocator,
-      Dispatch const &                           d ) const
-  {
-    std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> sparseMemoryRequirements(
-      sparseImageMemoryRequirements2Allocator );
-    uint32_t sparseMemoryRequirementCount;
-    d.vkGetImageSparseMemoryRequirements2KHR( m_device,
-                                              reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ),
-                                              &sparseMemoryRequirementCount,
-                                              nullptr );
-    sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
-    d.vkGetImageSparseMemoryRequirements2KHR(
-      m_device,
-      reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ),
-      &sparseMemoryRequirementCount,
-      reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) );
-    VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() );
-    return sparseMemoryRequirements;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::getImageSubresourceLayout( VULKAN_HPP_NAMESPACE::Image                    image,
-                                                            const VULKAN_HPP_NAMESPACE::ImageSubresource * pSubresource,
-                                                            VULKAN_HPP_NAMESPACE::SubresourceLayout *      pLayout,
-                                                            Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkGetImageSubresourceLayout( m_device,
-                                   static_cast<VkImage>( image ),
-                                   reinterpret_cast<const VkImageSubresource *>( pSubresource ),
-                                   reinterpret_cast<VkSubresourceLayout *>( pLayout ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::SubresourceLayout
-                                         Device::getImageSubresourceLayout( VULKAN_HPP_NAMESPACE::Image image,
-                                       const ImageSubresource &    subresource,
-                                       Dispatch const &            d ) const VULKAN_HPP_NOEXCEPT
-  {
-    VULKAN_HPP_NAMESPACE::SubresourceLayout layout;
-    d.vkGetImageSubresourceLayout( m_device,
-                                   static_cast<VkImage>( image ),
-                                   reinterpret_cast<const VkImageSubresource *>( &subresource ),
-                                   reinterpret_cast<VkSubresourceLayout *>( &layout ) );
-    return layout;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::getImageViewAddressNVX( VULKAN_HPP_NAMESPACE::ImageView                       imageView,
-                                    VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX * pProperties,
-                                    Dispatch const &                                      d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkGetImageViewAddressNVX( m_device,
-                                  static_cast<VkImageView>( imageView ),
-                                  reinterpret_cast<VkImageViewAddressPropertiesNVX *>( pProperties ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX>::type
-    Device::getImageViewAddressNVX( VULKAN_HPP_NAMESPACE::ImageView imageView, Dispatch const & d ) const
-  {
-    VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX properties;
-    Result                                              result = static_cast<Result>(
-      d.vkGetImageViewAddressNVX( m_device,
-                                  static_cast<VkImageView>( imageView ),
-                                  reinterpret_cast<VkImageViewAddressPropertiesNVX *>( &properties ) ) );
-    return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING "::Device::getImageViewAddressNVX" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE uint32_t Device::getImageViewHandleNVX( const VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX * pInfo,
-                                                            Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return d.vkGetImageViewHandleNVX( m_device, reinterpret_cast<const VkImageViewHandleInfoNVX *>( pInfo ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE uint32_t Device::getImageViewHandleNVX( const ImageViewHandleInfoNVX & info,
-                                                            Dispatch const &               d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return d.vkGetImageViewHandleNVX( m_device, reinterpret_cast<const VkImageViewHandleInfoNVX *>( &info ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#if defined( VK_USE_PLATFORM_ANDROID_KHR )
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryAndroidHardwareBufferANDROID(
-    const VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID * pInfo,
-    struct AHardwareBuffer **                                               pBuffer,
-    Dispatch const &                                                        d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkGetMemoryAndroidHardwareBufferANDROID(
-      m_device, reinterpret_cast<const VkMemoryGetAndroidHardwareBufferInfoANDROID *>( pInfo ), pBuffer ) );
-  }
-
-#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<struct AHardwareBuffer *>::type
-    Device::getMemoryAndroidHardwareBufferANDROID( const MemoryGetAndroidHardwareBufferInfoANDROID & info,
-                                                   Dispatch const &                                  d ) const
-  {
-    struct AHardwareBuffer * buffer;
-    Result                   result = static_cast<Result>( d.vkGetMemoryAndroidHardwareBufferANDROID(
-      m_device, reinterpret_cast<const VkMemoryGetAndroidHardwareBufferInfoANDROID *>( &info ), &buffer ) );
-    return createResultValue(
-      result, buffer, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryAndroidHardwareBufferANDROID" );
-  }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_USE_PLATFORM_ANDROID_KHR*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::getMemoryFdKHR( const VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR * pGetFdInfo,
-                            int *                                            pFd,
-                            Dispatch const &                                 d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkGetMemoryFdKHR( m_device, reinterpret_cast<const VkMemoryGetFdInfoKHR *>( pGetFdInfo ), pFd ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<int>::type
-    Device::getMemoryFdKHR( const MemoryGetFdInfoKHR & getFdInfo, Dispatch const & d ) const
-  {
-    int    fd;
-    Result result = static_cast<Result>(
-      d.vkGetMemoryFdKHR( m_device, reinterpret_cast<const VkMemoryGetFdInfoKHR *>( &getFdInfo ), &fd ) );
-    return createResultValue( result, fd, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryFdKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::getMemoryFdPropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
-                                      int                                                    fd,
-                                      VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR *          pMemoryFdProperties,
-                                      Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkGetMemoryFdPropertiesKHR( m_device,
-                                    static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ),
-                                    fd,
-                                    reinterpret_cast<VkMemoryFdPropertiesKHR *>( pMemoryFdProperties ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR>::type
-    Device::getMemoryFdPropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
-                                      int                                                    fd,
-                                      Dispatch const &                                       d ) const
-  {
-    VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR memoryFdProperties;
-    Result                                      result = static_cast<Result>(
-      d.vkGetMemoryFdPropertiesKHR( m_device,
-                                    static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ),
-                                    fd,
-                                    reinterpret_cast<VkMemoryFdPropertiesKHR *>( &memoryFdProperties ) ) );
-    return createResultValue(
-      result, memoryFdProperties, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryFdPropertiesKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryHostPointerPropertiesEXT(
-    VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
-    const void *                                           pHostPointer,
-    VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT * pMemoryHostPointerProperties,
-    Dispatch const &                                       d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkGetMemoryHostPointerPropertiesEXT(
-      m_device,
-      static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ),
-      pHostPointer,
-      reinterpret_cast<VkMemoryHostPointerPropertiesEXT *>( pMemoryHostPointerProperties ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT>::type
-    Device::getMemoryHostPointerPropertiesEXT( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
-                                               const void *                                           pHostPointer,
-                                               Dispatch const &                                       d ) const
-  {
-    VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT memoryHostPointerProperties;
-    Result result = static_cast<Result>( d.vkGetMemoryHostPointerPropertiesEXT(
-      m_device,
-      static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ),
-      pHostPointer,
-      reinterpret_cast<VkMemoryHostPointerPropertiesEXT *>( &memoryHostPointerProperties ) ) );
-    return createResultValue(
-      result, memoryHostPointerProperties, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryHostPointerPropertiesEXT" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#if defined( VK_USE_PLATFORM_WIN32_KHR )
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::getMemoryWin32HandleKHR( const VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR * pGetWin32HandleInfo,
-                                     HANDLE *                                                  pHandle,
-                                     Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkGetMemoryWin32HandleKHR(
-      m_device, reinterpret_cast<const VkMemoryGetWin32HandleInfoKHR *>( pGetWin32HandleInfo ), pHandle ) );
-  }
-
-#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<HANDLE>::type
-    Device::getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const & d ) const
-  {
-    HANDLE handle;
-    Result result = static_cast<Result>( d.vkGetMemoryWin32HandleKHR(
-      m_device, reinterpret_cast<const VkMemoryGetWin32HandleInfoKHR *>( &getWin32HandleInfo ), &handle ) );
-    return createResultValue( result, handle, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryWin32HandleKHR" );
-  }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#if defined( VK_USE_PLATFORM_WIN32_KHR )
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::getMemoryWin32HandleNV( VULKAN_HPP_NAMESPACE::DeviceMemory                    memory,
-                                    VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleType,
-                                    HANDLE *                                              pHandle,
-                                    Dispatch const &                                      d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkGetMemoryWin32HandleNV( m_device,
-                                  static_cast<VkDeviceMemory>( memory ),
-                                  static_cast<VkExternalMemoryHandleTypeFlagsNV>( handleType ),
-                                  pHandle ) );
-  }
-
-#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<HANDLE>::type
-                                          Device::getMemoryWin32HandleNV( VULKAN_HPP_NAMESPACE::DeviceMemory                    memory,
-                                    VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleType,
-                                    Dispatch const &                                      d ) const
-  {
-    HANDLE handle;
-    Result result =
-      static_cast<Result>( d.vkGetMemoryWin32HandleNV( m_device,
-                                                       static_cast<VkDeviceMemory>( memory ),
-                                                       static_cast<VkExternalMemoryHandleTypeFlagsNV>( handleType ),
-                                                       &handle ) );
-    return createResultValue( result, handle, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryWin32HandleNV" );
-  }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#if defined( VK_USE_PLATFORM_WIN32_KHR )
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryWin32HandlePropertiesKHR(
-    VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
-    HANDLE                                                 handle,
-    VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR * pMemoryWin32HandleProperties,
-    Dispatch const &                                       d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkGetMemoryWin32HandlePropertiesKHR(
-      m_device,
-      static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ),
-      handle,
-      reinterpret_cast<VkMemoryWin32HandlePropertiesKHR *>( pMemoryWin32HandleProperties ) ) );
-  }
-
-#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR>::type
-    Device::getMemoryWin32HandlePropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
-                                               HANDLE                                                 handle,
-                                               Dispatch const &                                       d ) const
-  {
-    VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR memoryWin32HandleProperties;
-    Result result = static_cast<Result>( d.vkGetMemoryWin32HandlePropertiesKHR(
-      m_device,
-      static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ),
-      handle,
-      reinterpret_cast<VkMemoryWin32HandlePropertiesKHR *>( &memoryWin32HandleProperties ) ) );
-    return createResultValue(
-      result, memoryWin32HandleProperties, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryWin32HandlePropertiesKHR" );
-  }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#if defined( VK_USE_PLATFORM_FUCHSIA )
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryZirconHandleFUCHSIA(
-    const VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo,
-    zx_handle_t *                                                  pZirconHandle,
-    Dispatch const &                                               d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkGetMemoryZirconHandleFUCHSIA(
-      m_device, reinterpret_cast<const VkMemoryGetZirconHandleInfoFUCHSIA *>( pGetZirconHandleInfo ), pZirconHandle ) );
-  }
-
-#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<zx_handle_t>::type
-    Device::getMemoryZirconHandleFUCHSIA( const MemoryGetZirconHandleInfoFUCHSIA & getZirconHandleInfo,
-                                          Dispatch const &                         d ) const
-  {
-    zx_handle_t zirconHandle;
-    Result      result = static_cast<Result>( d.vkGetMemoryZirconHandleFUCHSIA(
-      m_device, reinterpret_cast<const VkMemoryGetZirconHandleInfoFUCHSIA *>( &getZirconHandleInfo ), &zirconHandle ) );
-    return createResultValue(
-      result, zirconHandle, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryZirconHandleFUCHSIA" );
-  }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_USE_PLATFORM_FUCHSIA*/
-
-#if defined( VK_USE_PLATFORM_FUCHSIA )
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryZirconHandlePropertiesFUCHSIA(
-    VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits      handleType,
-    zx_handle_t                                                 zirconHandle,
-    VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA * pMemoryZirconHandleProperties,
-    Dispatch const &                                            d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkGetMemoryZirconHandlePropertiesFUCHSIA(
-      m_device,
-      static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ),
-      zirconHandle,
-      reinterpret_cast<VkMemoryZirconHandlePropertiesFUCHSIA *>( pMemoryZirconHandleProperties ) ) );
-  }
-
-#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA>::type
-    Device::getMemoryZirconHandlePropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
-                                                    zx_handle_t                                            zirconHandle,
-                                                    Dispatch const &                                       d ) const
-  {
-    VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA memoryZirconHandleProperties;
-    Result result = static_cast<Result>( d.vkGetMemoryZirconHandlePropertiesFUCHSIA(
-      m_device,
-      static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ),
-      zirconHandle,
-      reinterpret_cast<VkMemoryZirconHandlePropertiesFUCHSIA *>( &memoryZirconHandleProperties ) ) );
-    return createResultValue( result,
-                              memoryZirconHandleProperties,
-                              VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryZirconHandlePropertiesFUCHSIA" );
-  }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_USE_PLATFORM_FUCHSIA*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
-                                             uint32_t *                         pPresentationTimingCount,
-                                             VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE * pPresentationTimings,
-                                             Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkGetPastPresentationTimingGOOGLE(
-      m_device,
-      static_cast<VkSwapchainKHR>( swapchain ),
-      pPresentationTimingCount,
-      reinterpret_cast<VkPastPresentationTimingGOOGLE *>( pPresentationTimings ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename PastPresentationTimingGOOGLEAllocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
-    typename ResultValueType<std::vector<PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator>>::type
-    Device::getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d ) const
-  {
-    std::vector<PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator> presentationTimings;
-    uint32_t                                                                         presentationTimingCount;
-    Result                                                                           result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetPastPresentationTimingGOOGLE(
-        m_device, static_cast<VkSwapchainKHR>( swapchain ), &presentationTimingCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && presentationTimingCount )
-      {
-        presentationTimings.resize( presentationTimingCount );
-        result = static_cast<Result>( d.vkGetPastPresentationTimingGOOGLE(
-          m_device,
-          static_cast<VkSwapchainKHR>( swapchain ),
-          &presentationTimingCount,
-          reinterpret_cast<VkPastPresentationTimingGOOGLE *>( presentationTimings.data() ) ) );
-        VULKAN_HPP_ASSERT( presentationTimingCount <= presentationTimings.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( presentationTimingCount < presentationTimings.size() ) )
-    {
-      presentationTimings.resize( presentationTimingCount );
-    }
-    return createResultValue(
-      result, presentationTimings, VULKAN_HPP_NAMESPACE_STRING "::Device::getPastPresentationTimingGOOGLE" );
-  }
-
-  template <
-    typename PastPresentationTimingGOOGLEAllocator,
-    typename Dispatch,
-    typename B,
-    typename std::enable_if<std::is_same<typename B::value_type, PastPresentationTimingGOOGLE>::value, int>::type>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
-    typename ResultValueType<std::vector<PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator>>::type
-    Device::getPastPresentationTimingGOOGLE(
-      VULKAN_HPP_NAMESPACE::SwapchainKHR      swapchain,
-      PastPresentationTimingGOOGLEAllocator & pastPresentationTimingGOOGLEAllocator,
-      Dispatch const &                        d ) const
-  {
-    std::vector<PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator> presentationTimings(
-      pastPresentationTimingGOOGLEAllocator );
-    uint32_t presentationTimingCount;
-    Result   result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetPastPresentationTimingGOOGLE(
-        m_device, static_cast<VkSwapchainKHR>( swapchain ), &presentationTimingCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && presentationTimingCount )
-      {
-        presentationTimings.resize( presentationTimingCount );
-        result = static_cast<Result>( d.vkGetPastPresentationTimingGOOGLE(
-          m_device,
-          static_cast<VkSwapchainKHR>( swapchain ),
-          &presentationTimingCount,
-          reinterpret_cast<VkPastPresentationTimingGOOGLE *>( presentationTimings.data() ) ) );
-        VULKAN_HPP_ASSERT( presentationTimingCount <= presentationTimings.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( presentationTimingCount < presentationTimings.size() ) )
-    {
-      presentationTimings.resize( presentationTimingCount );
-    }
-    return createResultValue(
-      result, presentationTimings, VULKAN_HPP_NAMESPACE_STRING "::Device::getPastPresentationTimingGOOGLE" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::getPerformanceParameterINTEL( VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL parameter,
-                                          VULKAN_HPP_NAMESPACE::PerformanceValueINTEL *       pValue,
-                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkGetPerformanceParameterINTEL( m_device,
-                                        static_cast<VkPerformanceParameterTypeINTEL>( parameter ),
-                                        reinterpret_cast<VkPerformanceValueINTEL *>( pValue ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::PerformanceValueINTEL>::type
-    Device::getPerformanceParameterINTEL( VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL parameter,
-                                          Dispatch const &                                    d ) const
-  {
-    VULKAN_HPP_NAMESPACE::PerformanceValueINTEL value;
-    Result                                      result =
-      static_cast<Result>( d.vkGetPerformanceParameterINTEL( m_device,
-                                                             static_cast<VkPerformanceParameterTypeINTEL>( parameter ),
-                                                             reinterpret_cast<VkPerformanceValueINTEL *>( &value ) ) );
-    return createResultValue( result, value, VULKAN_HPP_NAMESPACE_STRING "::Device::getPerformanceParameterINTEL" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
-                                  size_t *                            pDataSize,
-                                  void *                              pData,
-                                  Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkGetPipelineCacheData( m_device, static_cast<VkPipelineCache>( pipelineCache ), pDataSize, pData ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Uint8_tAllocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
-    Device::getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, Dispatch const & d ) const
-  {
-    std::vector<uint8_t, Uint8_tAllocator> data;
-    size_t                                 dataSize;
-    Result                                 result;
-    do
-    {
-      result = static_cast<Result>(
-        d.vkGetPipelineCacheData( m_device, static_cast<VkPipelineCache>( pipelineCache ), &dataSize, nullptr ) );
-      if ( ( result == Result::eSuccess ) && dataSize )
-      {
-        data.resize( dataSize );
-        result = static_cast<Result>( d.vkGetPipelineCacheData( m_device,
-                                                                static_cast<VkPipelineCache>( pipelineCache ),
-                                                                &dataSize,
-                                                                reinterpret_cast<void *>( data.data() ) ) );
-        VULKAN_HPP_ASSERT( dataSize <= data.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( dataSize < data.size() ) )
-    {
-      data.resize( dataSize );
-    }
-    return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineCacheData" );
-  }
-
-  template <typename Uint8_tAllocator,
-            typename Dispatch,
-            typename B,
-            typename std::enable_if<std::is_same<typename B::value_type, uint8_t>::value, int>::type>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
-                       Device::getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
-                                  Uint8_tAllocator &                  uint8_tAllocator,
-                                  Dispatch const &                    d ) const
-  {
-    std::vector<uint8_t, Uint8_tAllocator> data( uint8_tAllocator );
-    size_t                                 dataSize;
-    Result                                 result;
-    do
-    {
-      result = static_cast<Result>(
-        d.vkGetPipelineCacheData( m_device, static_cast<VkPipelineCache>( pipelineCache ), &dataSize, nullptr ) );
-      if ( ( result == Result::eSuccess ) && dataSize )
-      {
-        data.resize( dataSize );
-        result = static_cast<Result>( d.vkGetPipelineCacheData( m_device,
-                                                                static_cast<VkPipelineCache>( pipelineCache ),
-                                                                &dataSize,
-                                                                reinterpret_cast<void *>( data.data() ) ) );
-        VULKAN_HPP_ASSERT( dataSize <= data.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( dataSize < data.size() ) )
-    {
-      data.resize( dataSize );
-    }
-    return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineCacheData" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getPipelineExecutableInternalRepresentationsKHR(
-    const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR *             pExecutableInfo,
-    uint32_t *                                                          pInternalRepresentationCount,
-    VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR * pInternalRepresentations,
-    Dispatch const &                                                    d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkGetPipelineExecutableInternalRepresentationsKHR(
-      m_device,
-      reinterpret_cast<const VkPipelineExecutableInfoKHR *>( pExecutableInfo ),
-      pInternalRepresentationCount,
-      reinterpret_cast<VkPipelineExecutableInternalRepresentationKHR *>( pInternalRepresentations ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename PipelineExecutableInternalRepresentationKHRAllocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
-    typename ResultValueType<std::vector<PipelineExecutableInternalRepresentationKHR,
-                                         PipelineExecutableInternalRepresentationKHRAllocator>>::type
-    Device::getPipelineExecutableInternalRepresentationsKHR( const PipelineExecutableInfoKHR & executableInfo,
-                                                             Dispatch const &                  d ) const
-  {
-    std::vector<PipelineExecutableInternalRepresentationKHR, PipelineExecutableInternalRepresentationKHRAllocator>
-             internalRepresentations;
-    uint32_t internalRepresentationCount;
-    Result   result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetPipelineExecutableInternalRepresentationsKHR(
-        m_device,
-        reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ),
-        &internalRepresentationCount,
-        nullptr ) );
-      if ( ( result == Result::eSuccess ) && internalRepresentationCount )
-      {
-        internalRepresentations.resize( internalRepresentationCount );
-        result = static_cast<Result>( d.vkGetPipelineExecutableInternalRepresentationsKHR(
-          m_device,
-          reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ),
-          &internalRepresentationCount,
-          reinterpret_cast<VkPipelineExecutableInternalRepresentationKHR *>( internalRepresentations.data() ) ) );
-        VULKAN_HPP_ASSERT( internalRepresentationCount <= internalRepresentations.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( internalRepresentationCount < internalRepresentations.size() ) )
-    {
-      internalRepresentations.resize( internalRepresentationCount );
-    }
-    return createResultValue( result,
-                              internalRepresentations,
-                              VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutableInternalRepresentationsKHR" );
-  }
-
-  template <
-    typename PipelineExecutableInternalRepresentationKHRAllocator,
-    typename Dispatch,
-    typename B,
-    typename std::enable_if<std::is_same<typename B::value_type, PipelineExecutableInternalRepresentationKHR>::value,
-                            int>::type>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
-    typename ResultValueType<std::vector<PipelineExecutableInternalRepresentationKHR,
-                                         PipelineExecutableInternalRepresentationKHRAllocator>>::type
-    Device::getPipelineExecutableInternalRepresentationsKHR(
-      const PipelineExecutableInfoKHR &                      executableInfo,
-      PipelineExecutableInternalRepresentationKHRAllocator & pipelineExecutableInternalRepresentationKHRAllocator,
-      Dispatch const &                                       d ) const
-  {
-    std::vector<PipelineExecutableInternalRepresentationKHR, PipelineExecutableInternalRepresentationKHRAllocator>
-             internalRepresentations( pipelineExecutableInternalRepresentationKHRAllocator );
-    uint32_t internalRepresentationCount;
-    Result   result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetPipelineExecutableInternalRepresentationsKHR(
-        m_device,
-        reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ),
-        &internalRepresentationCount,
-        nullptr ) );
-      if ( ( result == Result::eSuccess ) && internalRepresentationCount )
-      {
-        internalRepresentations.resize( internalRepresentationCount );
-        result = static_cast<Result>( d.vkGetPipelineExecutableInternalRepresentationsKHR(
-          m_device,
-          reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ),
-          &internalRepresentationCount,
-          reinterpret_cast<VkPipelineExecutableInternalRepresentationKHR *>( internalRepresentations.data() ) ) );
-        VULKAN_HPP_ASSERT( internalRepresentationCount <= internalRepresentations.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( internalRepresentationCount < internalRepresentations.size() ) )
-    {
-      internalRepresentations.resize( internalRepresentationCount );
-    }
-    return createResultValue( result,
-                              internalRepresentations,
-                              VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutableInternalRepresentationsKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::getPipelineExecutablePropertiesKHR( const VULKAN_HPP_NAMESPACE::PipelineInfoKHR * pPipelineInfo,
-                                                uint32_t *                                    pExecutableCount,
-                                                VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR * pProperties,
-                                                Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkGetPipelineExecutablePropertiesKHR( m_device,
-                                              reinterpret_cast<const VkPipelineInfoKHR *>( pPipelineInfo ),
-                                              pExecutableCount,
-                                              reinterpret_cast<VkPipelineExecutablePropertiesKHR *>( pProperties ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename PipelineExecutablePropertiesKHRAllocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<
-    std::vector<PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator>>::type
-    Device::getPipelineExecutablePropertiesKHR( const PipelineInfoKHR & pipelineInfo, Dispatch const & d ) const
-  {
-    std::vector<PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator> properties;
-    uint32_t                                                                               executableCount;
-    Result                                                                                 result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetPipelineExecutablePropertiesKHR(
-        m_device, reinterpret_cast<const VkPipelineInfoKHR *>( &pipelineInfo ), &executableCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && executableCount )
-      {
-        properties.resize( executableCount );
-        result = static_cast<Result>( d.vkGetPipelineExecutablePropertiesKHR(
-          m_device,
-          reinterpret_cast<const VkPipelineInfoKHR *>( &pipelineInfo ),
-          &executableCount,
-          reinterpret_cast<VkPipelineExecutablePropertiesKHR *>( properties.data() ) ) );
-        VULKAN_HPP_ASSERT( executableCount <= properties.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( executableCount < properties.size() ) )
-    {
-      properties.resize( executableCount );
-    }
-    return createResultValue(
-      result, properties, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutablePropertiesKHR" );
-  }
-
-  template <
-    typename PipelineExecutablePropertiesKHRAllocator,
-    typename Dispatch,
-    typename B,
-    typename std::enable_if<std::is_same<typename B::value_type, PipelineExecutablePropertiesKHR>::value, int>::type>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<
-    std::vector<PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator>>::type
-    Device::getPipelineExecutablePropertiesKHR(
-      const PipelineInfoKHR &                    pipelineInfo,
-      PipelineExecutablePropertiesKHRAllocator & pipelineExecutablePropertiesKHRAllocator,
-      Dispatch const &                           d ) const
-  {
-    std::vector<PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator> properties(
-      pipelineExecutablePropertiesKHRAllocator );
-    uint32_t executableCount;
-    Result   result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetPipelineExecutablePropertiesKHR(
-        m_device, reinterpret_cast<const VkPipelineInfoKHR *>( &pipelineInfo ), &executableCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && executableCount )
-      {
-        properties.resize( executableCount );
-        result = static_cast<Result>( d.vkGetPipelineExecutablePropertiesKHR(
-          m_device,
-          reinterpret_cast<const VkPipelineInfoKHR *>( &pipelineInfo ),
-          &executableCount,
-          reinterpret_cast<VkPipelineExecutablePropertiesKHR *>( properties.data() ) ) );
-        VULKAN_HPP_ASSERT( executableCount <= properties.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( executableCount < properties.size() ) )
-    {
-      properties.resize( executableCount );
-    }
-    return createResultValue(
-      result, properties, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutablePropertiesKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::getPipelineExecutableStatisticsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR * pExecutableInfo,
-                                                uint32_t *                                              pStatisticCount,
-                                                VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR *  pStatistics,
-                                                Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkGetPipelineExecutableStatisticsKHR( m_device,
-                                              reinterpret_cast<const VkPipelineExecutableInfoKHR *>( pExecutableInfo ),
-                                              pStatisticCount,
-                                              reinterpret_cast<VkPipelineExecutableStatisticKHR *>( pStatistics ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename PipelineExecutableStatisticKHRAllocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
-    typename ResultValueType<std::vector<PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator>>::type
-    Device::getPipelineExecutableStatisticsKHR( const PipelineExecutableInfoKHR & executableInfo,
-                                                Dispatch const &                  d ) const
-  {
-    std::vector<PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator> statistics;
-    uint32_t                                                                             statisticCount;
-    Result                                                                               result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetPipelineExecutableStatisticsKHR(
-        m_device,
-        reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ),
-        &statisticCount,
-        nullptr ) );
-      if ( ( result == Result::eSuccess ) && statisticCount )
-      {
-        statistics.resize( statisticCount );
-        result = static_cast<Result>( d.vkGetPipelineExecutableStatisticsKHR(
-          m_device,
-          reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ),
-          &statisticCount,
-          reinterpret_cast<VkPipelineExecutableStatisticKHR *>( statistics.data() ) ) );
-        VULKAN_HPP_ASSERT( statisticCount <= statistics.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( statisticCount < statistics.size() ) )
-    {
-      statistics.resize( statisticCount );
-    }
-    return createResultValue(
-      result, statistics, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutableStatisticsKHR" );
-  }
-
-  template <
-    typename PipelineExecutableStatisticKHRAllocator,
-    typename Dispatch,
-    typename B,
-    typename std::enable_if<std::is_same<typename B::value_type, PipelineExecutableStatisticKHR>::value, int>::type>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
-    typename ResultValueType<std::vector<PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator>>::type
-    Device::getPipelineExecutableStatisticsKHR(
-      const PipelineExecutableInfoKHR &         executableInfo,
-      PipelineExecutableStatisticKHRAllocator & pipelineExecutableStatisticKHRAllocator,
-      Dispatch const &                          d ) const
-  {
-    std::vector<PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator> statistics(
-      pipelineExecutableStatisticKHRAllocator );
-    uint32_t statisticCount;
-    Result   result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetPipelineExecutableStatisticsKHR(
-        m_device,
-        reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ),
-        &statisticCount,
-        nullptr ) );
-      if ( ( result == Result::eSuccess ) && statisticCount )
-      {
-        statistics.resize( statisticCount );
-        result = static_cast<Result>( d.vkGetPipelineExecutableStatisticsKHR(
-          m_device,
-          reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ),
-          &statisticCount,
-          reinterpret_cast<VkPipelineExecutableStatisticKHR *>( statistics.data() ) ) );
-        VULKAN_HPP_ASSERT( statisticCount <= statistics.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( statisticCount < statistics.size() ) )
-    {
-      statistics.resize( statisticCount );
-    }
-    return createResultValue(
-      result, statistics, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutableStatisticsKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::getPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType         objectType,
-                                                    uint64_t                                 objectHandle,
-                                                    VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot,
-                                                    uint64_t *                               pData,
-                                                    Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkGetPrivateDataEXT( m_device,
-                           static_cast<VkObjectType>( objectType ),
-                           objectHandle,
-                           static_cast<VkPrivateDataSlotEXT>( privateDataSlot ),
-                           pData );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t
-    Device::getPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType         objectType,
-                               uint64_t                                 objectHandle,
-                               VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot,
-                               Dispatch const &                         d ) const VULKAN_HPP_NOEXCEPT
-  {
-    uint64_t data;
-    d.vkGetPrivateDataEXT( m_device,
-                           static_cast<VkObjectType>( objectType ),
-                           objectHandle,
-                           static_cast<VkPrivateDataSlotEXT>( privateDataSlot ),
-                           &data );
-    return data;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::getQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool        queryPool,
-                                 uint32_t                               firstQuery,
-                                 uint32_t                               queryCount,
-                                 size_t                                 dataSize,
-                                 void *                                 pData,
-                                 VULKAN_HPP_NAMESPACE::DeviceSize       stride,
-                                 VULKAN_HPP_NAMESPACE::QueryResultFlags flags,
-                                 Dispatch const &                       d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkGetQueryPoolResults( m_device,
-                                                         static_cast<VkQueryPool>( queryPool ),
-                                                         firstQuery,
-                                                         queryCount,
-                                                         dataSize,
-                                                         pData,
-                                                         static_cast<VkDeviceSize>( stride ),
-                                                         static_cast<VkQueryResultFlags>( flags ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename T, typename Dispatch>
-  VULKAN_HPP_DEPRECATED( "This function is deprecated. Use one of the other flavours of it." )
-  VULKAN_HPP_NODISCARD
-    VULKAN_HPP_INLINE Result Device::getQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool        queryPool,
-                                                          uint32_t                               firstQuery,
-                                                          uint32_t                               queryCount,
-                                                          ArrayProxy<T> const &                  data,
-                                                          VULKAN_HPP_NAMESPACE::DeviceSize       stride,
-                                                          VULKAN_HPP_NAMESPACE::QueryResultFlags flags,
-                                                          Dispatch const &                       d ) const
-  {
-    Result result = static_cast<Result>( d.vkGetQueryPoolResults( m_device,
-                                                                  static_cast<VkQueryPool>( queryPool ),
-                                                                  firstQuery,
-                                                                  queryCount,
-                                                                  data.size() * sizeof( T ),
-                                                                  reinterpret_cast<void *>( data.data() ),
-                                                                  static_cast<VkDeviceSize>( stride ),
-                                                                  static_cast<VkQueryResultFlags>( flags ) ) );
-    return createResultValue(
-      result, VULKAN_HPP_NAMESPACE_STRING "::Device::getQueryPoolResults", { Result::eSuccess, Result::eNotReady } );
-  }
-
-  template <typename T, typename Allocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<T, Allocator>>
-                                         Device::getQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool        queryPool,
-                                 uint32_t                               firstQuery,
-                                 uint32_t                               queryCount,
-                                 size_t                                 dataSize,
-                                 VULKAN_HPP_NAMESPACE::DeviceSize       stride,
-                                 VULKAN_HPP_NAMESPACE::QueryResultFlags flags,
-                                 Dispatch const &                       d ) const
-  {
-    VULKAN_HPP_ASSERT( dataSize % sizeof( T ) == 0 );
-    std::vector<T, Allocator> data( dataSize / sizeof( T ) );
-    Result                    result = static_cast<Result>( d.vkGetQueryPoolResults( m_device,
-                                                                  static_cast<VkQueryPool>( queryPool ),
-                                                                  firstQuery,
-                                                                  queryCount,
-                                                                  data.size() * sizeof( T ),
-                                                                  reinterpret_cast<void *>( data.data() ),
-                                                                  static_cast<VkDeviceSize>( stride ),
-                                                                  static_cast<VkQueryResultFlags>( flags ) ) );
-    return createResultValue( result,
-                              data,
-                              VULKAN_HPP_NAMESPACE_STRING "::Device::getQueryPoolResults",
-                              { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eNotReady } );
-  }
-
-  template <typename T, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<T>
-                                         Device::getQueryPoolResult( VULKAN_HPP_NAMESPACE::QueryPool        queryPool,
-                                uint32_t                               firstQuery,
-                                uint32_t                               queryCount,
-                                VULKAN_HPP_NAMESPACE::DeviceSize       stride,
-                                VULKAN_HPP_NAMESPACE::QueryResultFlags flags,
-                                Dispatch const &                       d ) const
-  {
-    T      data;
-    Result result = static_cast<Result>( d.vkGetQueryPoolResults( m_device,
-                                                                  static_cast<VkQueryPool>( queryPool ),
-                                                                  firstQuery,
-                                                                  queryCount,
-                                                                  sizeof( T ),
-                                                                  reinterpret_cast<void *>( &data ),
-                                                                  static_cast<VkDeviceSize>( stride ),
-                                                                  static_cast<VkQueryResultFlags>( flags ) ) );
-    return createResultValue( result,
-                              data,
-                              VULKAN_HPP_NAMESPACE_STRING "::Device::getQueryPoolResult",
-                              { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eNotReady } );
+    Result result = static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesKHR( m_device,
+                                                                                 static_cast<VkPipeline>( pipeline ),
+                                                                                 firstGroup,
+                                                                                 groupCount,
+                                                                                 sizeof( T ),
+                                                                                 reinterpret_cast<void *>( &data ) ) );
+    return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandleKHR" );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -112621,147 +119662,40 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::getRayTracingShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
-                                                uint32_t                       firstGroup,
-                                                uint32_t                       groupCount,
-                                                size_t                         dataSize,
-                                                void *                         pData,
-                                                Dispatch const &               d ) const VULKAN_HPP_NOEXCEPT
+  VULKAN_HPP_INLINE void CommandBuffer::traceRaysIndirectKHR(
+    const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pRaygenShaderBindingTable,
+    const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pMissShaderBindingTable,
+    const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pHitShaderBindingTable,
+    const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pCallableShaderBindingTable,
+    VULKAN_HPP_NAMESPACE::DeviceAddress                         indirectDeviceAddress,
+    Dispatch const &                                            d ) const VULKAN_HPP_NOEXCEPT
   {
-    return static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesKHR(
-      m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, dataSize, pData ) );
+    d.vkCmdTraceRaysIndirectKHR(
+      m_commandBuffer,
+      reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( pRaygenShaderBindingTable ),
+      reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( pMissShaderBindingTable ),
+      reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( pHitShaderBindingTable ),
+      reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( pCallableShaderBindingTable ),
+      static_cast<VkDeviceAddress>( indirectDeviceAddress ) );
   }
 
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename T, typename Dispatch>
-  VULKAN_HPP_DEPRECATED( "This function is deprecated. Use one of the other flavours of it." )
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<void>::type Device::getRayTracingShaderGroupHandlesKHR(
-      VULKAN_HPP_NAMESPACE::Pipeline pipeline,
-      uint32_t                       firstGroup,
-      uint32_t                       groupCount,
-      ArrayProxy<T> const &          data,
-      Dispatch const &               d ) const
-  {
-    Result result =
-      static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesKHR( m_device,
-                                                                   static_cast<VkPipeline>( pipeline ),
-                                                                   firstGroup,
-                                                                   groupCount,
-                                                                   data.size() * sizeof( T ),
-                                                                   reinterpret_cast<void *>( data.data() ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandlesKHR" );
-  }
-
-  template <typename T, typename Allocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<std::vector<T, Allocator>>::type
-    Device::getRayTracingShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
-                                                uint32_t                       firstGroup,
-                                                uint32_t                       groupCount,
-                                                size_t                         dataSize,
-                                                Dispatch const &               d ) const
-  {
-    VULKAN_HPP_ASSERT( dataSize % sizeof( T ) == 0 );
-    std::vector<T, Allocator> data( dataSize / sizeof( T ) );
-    Result                    result =
-      static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesKHR( m_device,
-                                                                   static_cast<VkPipeline>( pipeline ),
-                                                                   firstGroup,
-                                                                   groupCount,
-                                                                   data.size() * sizeof( T ),
-                                                                   reinterpret_cast<void *>( data.data() ) ) );
-    return createResultValue(
-      result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandlesKHR" );
-  }
-
-  template <typename T, typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<T>::type
-    Device::getRayTracingShaderGroupHandleKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
-                                               uint32_t                       firstGroup,
-                                               uint32_t                       groupCount,
-                                               Dispatch const &               d ) const
-  {
-    T      data;
-    Result result = static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesKHR( m_device,
-                                                                                 static_cast<VkPipeline>( pipeline ),
-                                                                                 firstGroup,
-                                                                                 groupCount,
-                                                                                 sizeof( T ),
-                                                                                 reinterpret_cast<void *>( &data ) ) );
-    return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandleKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
   template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::getRayTracingShaderGroupHandlesNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
-                                               uint32_t                       firstGroup,
-                                               uint32_t                       groupCount,
-                                               size_t                         dataSize,
-                                               void *                         pData,
-                                               Dispatch const &               d ) const VULKAN_HPP_NOEXCEPT
+  VULKAN_HPP_INLINE void
+    CommandBuffer::traceRaysIndirectKHR( const StridedDeviceAddressRegionKHR & raygenShaderBindingTable,
+                                         const StridedDeviceAddressRegionKHR & missShaderBindingTable,
+                                         const StridedDeviceAddressRegionKHR & hitShaderBindingTable,
+                                         const StridedDeviceAddressRegionKHR & callableShaderBindingTable,
+                                         VULKAN_HPP_NAMESPACE::DeviceAddress   indirectDeviceAddress,
+                                         Dispatch const &                      d ) const VULKAN_HPP_NOEXCEPT
   {
-    return static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesNV(
-      m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, dataSize, pData ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename T, typename Dispatch>
-  VULKAN_HPP_DEPRECATED( "This function is deprecated. Use one of the other flavours of it." )
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<void>::type Device::getRayTracingShaderGroupHandlesNV(
-      VULKAN_HPP_NAMESPACE::Pipeline pipeline,
-      uint32_t                       firstGroup,
-      uint32_t                       groupCount,
-      ArrayProxy<T> const &          data,
-      Dispatch const &               d ) const
-  {
-    Result result =
-      static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesNV( m_device,
-                                                                  static_cast<VkPipeline>( pipeline ),
-                                                                  firstGroup,
-                                                                  groupCount,
-                                                                  data.size() * sizeof( T ),
-                                                                  reinterpret_cast<void *>( data.data() ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandlesNV" );
-  }
-
-  template <typename T, typename Allocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<std::vector<T, Allocator>>::type
-    Device::getRayTracingShaderGroupHandlesNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
-                                               uint32_t                       firstGroup,
-                                               uint32_t                       groupCount,
-                                               size_t                         dataSize,
-                                               Dispatch const &               d ) const
-  {
-    VULKAN_HPP_ASSERT( dataSize % sizeof( T ) == 0 );
-    std::vector<T, Allocator> data( dataSize / sizeof( T ) );
-    Result                    result =
-      static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesNV( m_device,
-                                                                  static_cast<VkPipeline>( pipeline ),
-                                                                  firstGroup,
-                                                                  groupCount,
-                                                                  data.size() * sizeof( T ),
-                                                                  reinterpret_cast<void *>( data.data() ) ) );
-    return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandlesNV" );
-  }
-
-  template <typename T, typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<T>::type
-    Device::getRayTracingShaderGroupHandleNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
-                                              uint32_t                       firstGroup,
-                                              uint32_t                       groupCount,
-                                              Dispatch const &               d ) const
-  {
-    T      data;
-    Result result = static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesNV( m_device,
-                                                                                static_cast<VkPipeline>( pipeline ),
-                                                                                firstGroup,
-                                                                                groupCount,
-                                                                                sizeof( T ),
-                                                                                reinterpret_cast<void *>( &data ) ) );
-    return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandleNV" );
+    d.vkCmdTraceRaysIndirectKHR(
+      m_commandBuffer,
+      reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &raygenShaderBindingTable ),
+      reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &missShaderBindingTable ),
+      reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &hitShaderBindingTable ),
+      reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &callableShaderBindingTable ),
+      static_cast<VkDeviceAddress>( indirectDeviceAddress ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -112777,143 +119711,134 @@ namespace VULKAN_HPP_NAMESPACE
   }
 
   template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::getRefreshCycleDurationGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR                 swapchain,
-                                           VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE * pDisplayTimingProperties,
-                                           Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  VULKAN_HPP_INLINE void
+    CommandBuffer::setRayTracingPipelineStackSizeKHR( uint32_t         pipelineStackSize,
+                                                      Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
-    return static_cast<Result>( d.vkGetRefreshCycleDurationGOOGLE(
-      m_device,
-      static_cast<VkSwapchainKHR>( swapchain ),
-      reinterpret_cast<VkRefreshCycleDurationGOOGLE *>( pDisplayTimingProperties ) ) );
+    d.vkCmdSetRayTracingPipelineStackSizeKHR( m_commandBuffer, pipelineStackSize );
+  }
+
+  //=== VK_EXT_vertex_input_dynamic_state ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setVertexInputEXT(
+    uint32_t                                                          vertexBindingDescriptionCount,
+    const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT *   pVertexBindingDescriptions,
+    uint32_t                                                          vertexAttributeDescriptionCount,
+    const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT * pVertexAttributeDescriptions,
+    Dispatch const &                                                  d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetVertexInputEXT(
+      m_commandBuffer,
+      vertexBindingDescriptionCount,
+      reinterpret_cast<const VkVertexInputBindingDescription2EXT *>( pVertexBindingDescriptions ),
+      vertexAttributeDescriptionCount,
+      reinterpret_cast<const VkVertexInputAttributeDescription2EXT *>( pVertexAttributeDescriptions ) );
   }
 
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE>::type
-    Device::getRefreshCycleDurationGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::setVertexInputEXT(
+    ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT> const &   vertexBindingDescriptions,
+    ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT> const & vertexAttributeDescriptions,
+    Dispatch const &                                                                    d ) const VULKAN_HPP_NOEXCEPT
   {
-    VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE displayTimingProperties;
-    Result                                           result = static_cast<Result>( d.vkGetRefreshCycleDurationGOOGLE(
-      m_device,
-      static_cast<VkSwapchainKHR>( swapchain ),
-      reinterpret_cast<VkRefreshCycleDurationGOOGLE *>( &displayTimingProperties ) ) );
-    return createResultValue(
-      result, displayTimingProperties, VULKAN_HPP_NAMESPACE_STRING "::Device::getRefreshCycleDurationGOOGLE" );
+    d.vkCmdSetVertexInputEXT(
+      m_commandBuffer,
+      vertexBindingDescriptions.size(),
+      reinterpret_cast<const VkVertexInputBindingDescription2EXT *>( vertexBindingDescriptions.data() ),
+      vertexAttributeDescriptions.size(),
+      reinterpret_cast<const VkVertexInputAttributeDescription2EXT *>( vertexAttributeDescriptions.data() ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::getRenderAreaGranularity( VULKAN_HPP_NAMESPACE::RenderPass renderPass,
-                                                           VULKAN_HPP_NAMESPACE::Extent2D * pGranularity,
-                                                           Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkGetRenderAreaGranularity(
-      m_device, static_cast<VkRenderPass>( renderPass ), reinterpret_cast<VkExtent2D *>( pGranularity ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Extent2D
-                                         Device::getRenderAreaGranularity( VULKAN_HPP_NAMESPACE::RenderPass renderPass,
-                                      Dispatch const &                 d ) const VULKAN_HPP_NOEXCEPT
-  {
-    VULKAN_HPP_NAMESPACE::Extent2D granularity;
-    d.vkGetRenderAreaGranularity(
-      m_device, static_cast<VkRenderPass>( renderPass ), reinterpret_cast<VkExtent2D *>( &granularity ) );
-    return granularity;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#if defined( VK_USE_PLATFORM_FUCHSIA )
+  //=== VK_FUCHSIA_external_memory ===
 
   template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSemaphoreCounterValue(
-    VULKAN_HPP_NAMESPACE::Semaphore semaphore, uint64_t * pValue, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryZirconHandleFUCHSIA(
+    const VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo,
+    zx_handle_t *                                                  pZirconHandle,
+    Dispatch const &                                               d ) const VULKAN_HPP_NOEXCEPT
   {
-    return static_cast<Result>(
-      d.vkGetSemaphoreCounterValue( m_device, static_cast<VkSemaphore>( semaphore ), pValue ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<uint64_t>::type
-    Device::getSemaphoreCounterValue( VULKAN_HPP_NAMESPACE::Semaphore semaphore, Dispatch const & d ) const
-  {
-    uint64_t value;
-    Result   result =
-      static_cast<Result>( d.vkGetSemaphoreCounterValue( m_device, static_cast<VkSemaphore>( semaphore ), &value ) );
-    return createResultValue( result, value, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreCounterValue" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSemaphoreCounterValueKHR(
-    VULKAN_HPP_NAMESPACE::Semaphore semaphore, uint64_t * pValue, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkGetSemaphoreCounterValueKHR( m_device, static_cast<VkSemaphore>( semaphore ), pValue ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<uint64_t>::type
-    Device::getSemaphoreCounterValueKHR( VULKAN_HPP_NAMESPACE::Semaphore semaphore, Dispatch const & d ) const
-  {
-    uint64_t value;
-    Result   result =
-      static_cast<Result>( d.vkGetSemaphoreCounterValueKHR( m_device, static_cast<VkSemaphore>( semaphore ), &value ) );
-    return createResultValue( result, value, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreCounterValueKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::getSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR * pGetFdInfo,
-                               int *                                               pFd,
-                               Dispatch const &                                    d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkGetSemaphoreFdKHR( m_device, reinterpret_cast<const VkSemaphoreGetFdInfoKHR *>( pGetFdInfo ), pFd ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<int>::type
-    Device::getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR & getFdInfo, Dispatch const & d ) const
-  {
-    int    fd;
-    Result result = static_cast<Result>(
-      d.vkGetSemaphoreFdKHR( m_device, reinterpret_cast<const VkSemaphoreGetFdInfoKHR *>( &getFdInfo ), &fd ) );
-    return createResultValue( result, fd, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreFdKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#if defined( VK_USE_PLATFORM_WIN32_KHR )
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSemaphoreWin32HandleKHR(
-    const VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR * pGetWin32HandleInfo,
-    HANDLE *                                                     pHandle,
-    Dispatch const &                                             d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkGetSemaphoreWin32HandleKHR(
-      m_device, reinterpret_cast<const VkSemaphoreGetWin32HandleInfoKHR *>( pGetWin32HandleInfo ), pHandle ) );
+    return static_cast<Result>( d.vkGetMemoryZirconHandleFUCHSIA(
+      m_device, reinterpret_cast<const VkMemoryGetZirconHandleInfoFUCHSIA *>( pGetZirconHandleInfo ), pZirconHandle ) );
   }
 
 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<HANDLE>::type
-    Device::getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo,
-                                        Dispatch const &                       d ) const
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<zx_handle_t>::type
+    Device::getMemoryZirconHandleFUCHSIA( const MemoryGetZirconHandleInfoFUCHSIA & getZirconHandleInfo,
+                                          Dispatch const &                         d ) const
   {
-    HANDLE handle;
-    Result result = static_cast<Result>( d.vkGetSemaphoreWin32HandleKHR(
-      m_device, reinterpret_cast<const VkSemaphoreGetWin32HandleInfoKHR *>( &getWin32HandleInfo ), &handle ) );
-    return createResultValue( result, handle, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreWin32HandleKHR" );
+    zx_handle_t zirconHandle;
+    Result      result = static_cast<Result>( d.vkGetMemoryZirconHandleFUCHSIA(
+      m_device, reinterpret_cast<const VkMemoryGetZirconHandleInfoFUCHSIA *>( &getZirconHandleInfo ), &zirconHandle ) );
+    return createResultValue(
+      result, zirconHandle, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryZirconHandleFUCHSIA" );
   }
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_USE_PLATFORM_WIN32_KHR*/
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryZirconHandlePropertiesFUCHSIA(
+    VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits      handleType,
+    zx_handle_t                                                 zirconHandle,
+    VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA * pMemoryZirconHandleProperties,
+    Dispatch const &                                            d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkGetMemoryZirconHandlePropertiesFUCHSIA(
+      m_device,
+      static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ),
+      zirconHandle,
+      reinterpret_cast<VkMemoryZirconHandlePropertiesFUCHSIA *>( pMemoryZirconHandleProperties ) ) );
+  }
+
+#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA>::type
+    Device::getMemoryZirconHandlePropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
+                                                    zx_handle_t                                            zirconHandle,
+                                                    Dispatch const &                                       d ) const
+  {
+    VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA memoryZirconHandleProperties;
+    Result result = static_cast<Result>( d.vkGetMemoryZirconHandlePropertiesFUCHSIA(
+      m_device,
+      static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ),
+      zirconHandle,
+      reinterpret_cast<VkMemoryZirconHandlePropertiesFUCHSIA *>( &memoryZirconHandleProperties ) ) );
+    return createResultValue( result,
+                              memoryZirconHandleProperties,
+                              VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryZirconHandlePropertiesFUCHSIA" );
+  }
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VK_USE_PLATFORM_FUCHSIA*/
 
 #if defined( VK_USE_PLATFORM_FUCHSIA )
+  //=== VK_FUCHSIA_external_semaphore ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::importSemaphoreZirconHandleFUCHSIA(
+    const VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA * pImportSemaphoreZirconHandleInfo,
+    Dispatch const &                                                     d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkImportSemaphoreZirconHandleFUCHSIA(
+      m_device,
+      reinterpret_cast<const VkImportSemaphoreZirconHandleInfoFUCHSIA *>( pImportSemaphoreZirconHandleInfo ) ) );
+  }
+
+#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
+                                          Device::importSemaphoreZirconHandleFUCHSIA(
+      const ImportSemaphoreZirconHandleInfoFUCHSIA & importSemaphoreZirconHandleInfo, Dispatch const & d ) const
+  {
+    Result result = static_cast<Result>( d.vkImportSemaphoreZirconHandleFUCHSIA(
+      m_device,
+      reinterpret_cast<const VkImportSemaphoreZirconHandleInfoFUCHSIA *>( &importSemaphoreZirconHandleInfo ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importSemaphoreZirconHandleFUCHSIA" );
+  }
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSemaphoreZirconHandleFUCHSIA(
     const VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo,
@@ -112943,1931 +119868,48 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VK_USE_PLATFORM_FUCHSIA*/
 
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline            pipeline,
-                              VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage,
-                              VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD   infoType,
-                              size_t *                                  pInfoSize,
-                              void *                                    pInfo,
-                              Dispatch const &                          d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkGetShaderInfoAMD( m_device,
-                                                      static_cast<VkPipeline>( pipeline ),
-                                                      static_cast<VkShaderStageFlagBits>( shaderStage ),
-                                                      static_cast<VkShaderInfoTypeAMD>( infoType ),
-                                                      pInfoSize,
-                                                      pInfo ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Uint8_tAllocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
-                       Device::getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline            pipeline,
-                              VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage,
-                              VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD   infoType,
-                              Dispatch const &                          d ) const
-  {
-    std::vector<uint8_t, Uint8_tAllocator> info;
-    size_t                                 infoSize;
-    Result                                 result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetShaderInfoAMD( m_device,
-                                                          static_cast<VkPipeline>( pipeline ),
-                                                          static_cast<VkShaderStageFlagBits>( shaderStage ),
-                                                          static_cast<VkShaderInfoTypeAMD>( infoType ),
-                                                          &infoSize,
-                                                          nullptr ) );
-      if ( ( result == Result::eSuccess ) && infoSize )
-      {
-        info.resize( infoSize );
-        result = static_cast<Result>( d.vkGetShaderInfoAMD( m_device,
-                                                            static_cast<VkPipeline>( pipeline ),
-                                                            static_cast<VkShaderStageFlagBits>( shaderStage ),
-                                                            static_cast<VkShaderInfoTypeAMD>( infoType ),
-                                                            &infoSize,
-                                                            reinterpret_cast<void *>( info.data() ) ) );
-        VULKAN_HPP_ASSERT( infoSize <= info.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( infoSize < info.size() ) )
-    {
-      info.resize( infoSize );
-    }
-    return createResultValue( result, info, VULKAN_HPP_NAMESPACE_STRING "::Device::getShaderInfoAMD" );
-  }
-
-  template <typename Uint8_tAllocator,
-            typename Dispatch,
-            typename B,
-            typename std::enable_if<std::is_same<typename B::value_type, uint8_t>::value, int>::type>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
-                       Device::getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline            pipeline,
-                              VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage,
-                              VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD   infoType,
-                              Uint8_tAllocator &                        uint8_tAllocator,
-                              Dispatch const &                          d ) const
-  {
-    std::vector<uint8_t, Uint8_tAllocator> info( uint8_tAllocator );
-    size_t                                 infoSize;
-    Result                                 result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetShaderInfoAMD( m_device,
-                                                          static_cast<VkPipeline>( pipeline ),
-                                                          static_cast<VkShaderStageFlagBits>( shaderStage ),
-                                                          static_cast<VkShaderInfoTypeAMD>( infoType ),
-                                                          &infoSize,
-                                                          nullptr ) );
-      if ( ( result == Result::eSuccess ) && infoSize )
-      {
-        info.resize( infoSize );
-        result = static_cast<Result>( d.vkGetShaderInfoAMD( m_device,
-                                                            static_cast<VkPipeline>( pipeline ),
-                                                            static_cast<VkShaderStageFlagBits>( shaderStage ),
-                                                            static_cast<VkShaderInfoTypeAMD>( infoType ),
-                                                            &infoSize,
-                                                            reinterpret_cast<void *>( info.data() ) ) );
-        VULKAN_HPP_ASSERT( infoSize <= info.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( infoSize < info.size() ) )
-    {
-      info.resize( infoSize );
-    }
-    return createResultValue( result, info, VULKAN_HPP_NAMESPACE_STRING "::Device::getShaderInfoAMD" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+  //=== VK_EXT_extended_dynamic_state2 ===
 
   template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::getSwapchainCounterEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR              swapchain,
-                                    VULKAN_HPP_NAMESPACE::SurfaceCounterFlagBitsEXT counter,
-                                    uint64_t *                                      pCounterValue,
-                                    Dispatch const &                                d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkGetSwapchainCounterEXT( m_device,
-                                                            static_cast<VkSwapchainKHR>( swapchain ),
-                                                            static_cast<VkSurfaceCounterFlagBitsEXT>( counter ),
-                                                            pCounterValue ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<uint64_t>::type
-                                          Device::getSwapchainCounterEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR              swapchain,
-                                    VULKAN_HPP_NAMESPACE::SurfaceCounterFlagBitsEXT counter,
-                                    Dispatch const &                                d ) const
-  {
-    uint64_t counterValue;
-    Result   result =
-      static_cast<Result>( d.vkGetSwapchainCounterEXT( m_device,
-                                                       static_cast<VkSwapchainKHR>( swapchain ),
-                                                       static_cast<VkSurfaceCounterFlagBitsEXT>( counter ),
-                                                       &counterValue ) );
-    return createResultValue( result, counterValue, VULKAN_HPP_NAMESPACE_STRING "::Device::getSwapchainCounterEXT" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::getSwapchainImagesKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
-                                   uint32_t *                         pSwapchainImageCount,
-                                   VULKAN_HPP_NAMESPACE::Image *      pSwapchainImages,
-                                   Dispatch const &                   d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkGetSwapchainImagesKHR( m_device,
-                                                           static_cast<VkSwapchainKHR>( swapchain ),
-                                                           pSwapchainImageCount,
-                                                           reinterpret_cast<VkImage *>( pSwapchainImages ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename ImageAllocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<Image, ImageAllocator>>::type
-    Device::getSwapchainImagesKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d ) const
-  {
-    std::vector<Image, ImageAllocator> swapchainImages;
-    uint32_t                           swapchainImageCount;
-    Result                             result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetSwapchainImagesKHR(
-        m_device, static_cast<VkSwapchainKHR>( swapchain ), &swapchainImageCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && swapchainImageCount )
-      {
-        swapchainImages.resize( swapchainImageCount );
-        result =
-          static_cast<Result>( d.vkGetSwapchainImagesKHR( m_device,
-                                                          static_cast<VkSwapchainKHR>( swapchain ),
-                                                          &swapchainImageCount,
-                                                          reinterpret_cast<VkImage *>( swapchainImages.data() ) ) );
-        VULKAN_HPP_ASSERT( swapchainImageCount <= swapchainImages.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( swapchainImageCount < swapchainImages.size() ) )
-    {
-      swapchainImages.resize( swapchainImageCount );
-    }
-    return createResultValue( result, swapchainImages, VULKAN_HPP_NAMESPACE_STRING "::Device::getSwapchainImagesKHR" );
-  }
-
-  template <typename ImageAllocator,
-            typename Dispatch,
-            typename B,
-            typename std::enable_if<std::is_same<typename B::value_type, Image>::value, int>::type>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<Image, ImageAllocator>>::type
-                       Device::getSwapchainImagesKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
-                                   ImageAllocator &                   imageAllocator,
-                                   Dispatch const &                   d ) const
-  {
-    std::vector<Image, ImageAllocator> swapchainImages( imageAllocator );
-    uint32_t                           swapchainImageCount;
-    Result                             result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetSwapchainImagesKHR(
-        m_device, static_cast<VkSwapchainKHR>( swapchain ), &swapchainImageCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && swapchainImageCount )
-      {
-        swapchainImages.resize( swapchainImageCount );
-        result =
-          static_cast<Result>( d.vkGetSwapchainImagesKHR( m_device,
-                                                          static_cast<VkSwapchainKHR>( swapchain ),
-                                                          &swapchainImageCount,
-                                                          reinterpret_cast<VkImage *>( swapchainImages.data() ) ) );
-        VULKAN_HPP_ASSERT( swapchainImageCount <= swapchainImages.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( swapchainImageCount < swapchainImages.size() ) )
-    {
-      swapchainImages.resize( swapchainImageCount );
-    }
-    return createResultValue( result, swapchainImages, VULKAN_HPP_NAMESPACE_STRING "::Device::getSwapchainImagesKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSwapchainStatusKHR(
-    VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkGetSwapchainStatusKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ) ) );
-  }
-#else
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::getSwapchainStatusKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d ) const
-  {
-    Result result =
-      static_cast<Result>( d.vkGetSwapchainStatusKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ) ) );
-    return createResultValue(
-      result,
-      VULKAN_HPP_NAMESPACE_STRING "::Device::getSwapchainStatusKHR",
-      { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR } );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::getValidationCacheDataEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache,
-                                       size_t *                                 pDataSize,
-                                       void *                                   pData,
-                                       Dispatch const &                         d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkGetValidationCacheDataEXT(
-      m_device, static_cast<VkValidationCacheEXT>( validationCache ), pDataSize, pData ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Uint8_tAllocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
-                       Device::getValidationCacheDataEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache,
-                                       Dispatch const &                         d ) const
-  {
-    std::vector<uint8_t, Uint8_tAllocator> data;
-    size_t                                 dataSize;
-    Result                                 result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetValidationCacheDataEXT(
-        m_device, static_cast<VkValidationCacheEXT>( validationCache ), &dataSize, nullptr ) );
-      if ( ( result == Result::eSuccess ) && dataSize )
-      {
-        data.resize( dataSize );
-        result =
-          static_cast<Result>( d.vkGetValidationCacheDataEXT( m_device,
-                                                              static_cast<VkValidationCacheEXT>( validationCache ),
-                                                              &dataSize,
-                                                              reinterpret_cast<void *>( data.data() ) ) );
-        VULKAN_HPP_ASSERT( dataSize <= data.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( dataSize < data.size() ) )
-    {
-      data.resize( dataSize );
-    }
-    return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getValidationCacheDataEXT" );
-  }
-
-  template <typename Uint8_tAllocator,
-            typename Dispatch,
-            typename B,
-            typename std::enable_if<std::is_same<typename B::value_type, uint8_t>::value, int>::type>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
-                       Device::getValidationCacheDataEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache,
-                                       Uint8_tAllocator &                       uint8_tAllocator,
-                                       Dispatch const &                         d ) const
-  {
-    std::vector<uint8_t, Uint8_tAllocator> data( uint8_tAllocator );
-    size_t                                 dataSize;
-    Result                                 result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetValidationCacheDataEXT(
-        m_device, static_cast<VkValidationCacheEXT>( validationCache ), &dataSize, nullptr ) );
-      if ( ( result == Result::eSuccess ) && dataSize )
-      {
-        data.resize( dataSize );
-        result =
-          static_cast<Result>( d.vkGetValidationCacheDataEXT( m_device,
-                                                              static_cast<VkValidationCacheEXT>( validationCache ),
-                                                              &dataSize,
-                                                              reinterpret_cast<void *>( data.data() ) ) );
-        VULKAN_HPP_ASSERT( dataSize <= data.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( dataSize < data.size() ) )
-    {
-      data.resize( dataSize );
-    }
-    return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getValidationCacheDataEXT" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#if defined( VK_ENABLE_BETA_EXTENSIONS )
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getVideoSessionMemoryRequirementsKHR(
-    VULKAN_HPP_NAMESPACE::VideoSessionKHR               videoSession,
-    uint32_t *                                          pVideoSessionMemoryRequirementsCount,
-    VULKAN_HPP_NAMESPACE::VideoGetMemoryPropertiesKHR * pVideoSessionMemoryRequirements,
-    Dispatch const &                                    d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkGetVideoSessionMemoryRequirementsKHR(
-      m_device,
-      static_cast<VkVideoSessionKHR>( videoSession ),
-      pVideoSessionMemoryRequirementsCount,
-      reinterpret_cast<VkVideoGetMemoryPropertiesKHR *>( pVideoSessionMemoryRequirements ) ) );
-  }
-
-#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename VideoGetMemoryPropertiesKHRAllocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
-    typename ResultValueType<std::vector<VideoGetMemoryPropertiesKHR, VideoGetMemoryPropertiesKHRAllocator>>::type
-    Device::getVideoSessionMemoryRequirementsKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession,
-                                                  Dispatch const &                      d ) const
-  {
-    std::vector<VideoGetMemoryPropertiesKHR, VideoGetMemoryPropertiesKHRAllocator> videoSessionMemoryRequirements;
-    uint32_t                                                                       videoSessionMemoryRequirementsCount;
-    Result                                                                         result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetVideoSessionMemoryRequirementsKHR(
-        m_device, static_cast<VkVideoSessionKHR>( videoSession ), &videoSessionMemoryRequirementsCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && videoSessionMemoryRequirementsCount )
-      {
-        videoSessionMemoryRequirements.resize( videoSessionMemoryRequirementsCount );
-        result = static_cast<Result>( d.vkGetVideoSessionMemoryRequirementsKHR(
-          m_device,
-          static_cast<VkVideoSessionKHR>( videoSession ),
-          &videoSessionMemoryRequirementsCount,
-          reinterpret_cast<VkVideoGetMemoryPropertiesKHR *>( videoSessionMemoryRequirements.data() ) ) );
-        VULKAN_HPP_ASSERT( videoSessionMemoryRequirementsCount <= videoSessionMemoryRequirements.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) &&
-         ( videoSessionMemoryRequirementsCount < videoSessionMemoryRequirements.size() ) )
-    {
-      videoSessionMemoryRequirements.resize( videoSessionMemoryRequirementsCount );
-    }
-    return createResultValue( result,
-                              videoSessionMemoryRequirements,
-                              VULKAN_HPP_NAMESPACE_STRING "::Device::getVideoSessionMemoryRequirementsKHR" );
-  }
-
-  template <
-    typename VideoGetMemoryPropertiesKHRAllocator,
-    typename Dispatch,
-    typename B,
-    typename std::enable_if<std::is_same<typename B::value_type, VideoGetMemoryPropertiesKHR>::value, int>::type>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
-    typename ResultValueType<std::vector<VideoGetMemoryPropertiesKHR, VideoGetMemoryPropertiesKHRAllocator>>::type
-    Device::getVideoSessionMemoryRequirementsKHR(
-      VULKAN_HPP_NAMESPACE::VideoSessionKHR  videoSession,
-      VideoGetMemoryPropertiesKHRAllocator & videoGetMemoryPropertiesKHRAllocator,
-      Dispatch const &                       d ) const
-  {
-    std::vector<VideoGetMemoryPropertiesKHR, VideoGetMemoryPropertiesKHRAllocator> videoSessionMemoryRequirements(
-      videoGetMemoryPropertiesKHRAllocator );
-    uint32_t videoSessionMemoryRequirementsCount;
-    Result   result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetVideoSessionMemoryRequirementsKHR(
-        m_device, static_cast<VkVideoSessionKHR>( videoSession ), &videoSessionMemoryRequirementsCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && videoSessionMemoryRequirementsCount )
-      {
-        videoSessionMemoryRequirements.resize( videoSessionMemoryRequirementsCount );
-        result = static_cast<Result>( d.vkGetVideoSessionMemoryRequirementsKHR(
-          m_device,
-          static_cast<VkVideoSessionKHR>( videoSession ),
-          &videoSessionMemoryRequirementsCount,
-          reinterpret_cast<VkVideoGetMemoryPropertiesKHR *>( videoSessionMemoryRequirements.data() ) ) );
-        VULKAN_HPP_ASSERT( videoSessionMemoryRequirementsCount <= videoSessionMemoryRequirements.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) &&
-         ( videoSessionMemoryRequirementsCount < videoSessionMemoryRequirements.size() ) )
-    {
-      videoSessionMemoryRequirements.resize( videoSessionMemoryRequirementsCount );
-    }
-    return createResultValue( result,
-                              videoSessionMemoryRequirements,
-                              VULKAN_HPP_NAMESPACE_STRING "::Device::getVideoSessionMemoryRequirementsKHR" );
-  }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_ENABLE_BETA_EXTENSIONS*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::importFenceFdKHR( const VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR * pImportFenceFdInfo,
-                              Dispatch const &                                   d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkImportFenceFdKHR( m_device, reinterpret_cast<const VkImportFenceFdInfoKHR *>( pImportFenceFdInfo ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
-    Device::importFenceFdKHR( const ImportFenceFdInfoKHR & importFenceFdInfo, Dispatch const & d ) const
-  {
-    Result result = static_cast<Result>(
-      d.vkImportFenceFdKHR( m_device, reinterpret_cast<const VkImportFenceFdInfoKHR *>( &importFenceFdInfo ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importFenceFdKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#if defined( VK_USE_PLATFORM_WIN32_KHR )
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::importFenceWin32HandleKHR(
-    const VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR * pImportFenceWin32HandleInfo,
-    Dispatch const &                                            d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkImportFenceWin32HandleKHR(
-      m_device, reinterpret_cast<const VkImportFenceWin32HandleInfoKHR *>( pImportFenceWin32HandleInfo ) ) );
-  }
-
-#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
-    Device::importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo,
-                                       Dispatch const &                      d ) const
-  {
-    Result result = static_cast<Result>( d.vkImportFenceWin32HandleKHR(
-      m_device, reinterpret_cast<const VkImportFenceWin32HandleInfoKHR *>( &importFenceWin32HandleInfo ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importFenceWin32HandleKHR" );
-  }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_USE_PLATFORM_WIN32_KHR*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::importSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR * pImportSemaphoreFdInfo,
-                                  Dispatch const &                                       d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkImportSemaphoreFdKHR(
-      m_device, reinterpret_cast<const VkImportSemaphoreFdInfoKHR *>( pImportSemaphoreFdInfo ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
-    Device::importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo, Dispatch const & d ) const
-  {
-    Result result = static_cast<Result>( d.vkImportSemaphoreFdKHR(
-      m_device, reinterpret_cast<const VkImportSemaphoreFdInfoKHR *>( &importSemaphoreFdInfo ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importSemaphoreFdKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#if defined( VK_USE_PLATFORM_WIN32_KHR )
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::importSemaphoreWin32HandleKHR(
-    const VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR * pImportSemaphoreWin32HandleInfo,
-    Dispatch const &                                                d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkImportSemaphoreWin32HandleKHR(
-      m_device, reinterpret_cast<const VkImportSemaphoreWin32HandleInfoKHR *>( pImportSemaphoreWin32HandleInfo ) ) );
-  }
-
-#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
-    Device::importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo,
-                                           Dispatch const &                          d ) const
-  {
-    Result result = static_cast<Result>( d.vkImportSemaphoreWin32HandleKHR(
-      m_device, reinterpret_cast<const VkImportSemaphoreWin32HandleInfoKHR *>( &importSemaphoreWin32HandleInfo ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importSemaphoreWin32HandleKHR" );
-  }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#if defined( VK_USE_PLATFORM_FUCHSIA )
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::importSemaphoreZirconHandleFUCHSIA(
-    const VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA * pImportSemaphoreZirconHandleInfo,
-    Dispatch const &                                                     d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkImportSemaphoreZirconHandleFUCHSIA(
-      m_device,
-      reinterpret_cast<const VkImportSemaphoreZirconHandleInfoFUCHSIA *>( pImportSemaphoreZirconHandleInfo ) ) );
-  }
-
-#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
-                                          Device::importSemaphoreZirconHandleFUCHSIA(
-      const ImportSemaphoreZirconHandleInfoFUCHSIA & importSemaphoreZirconHandleInfo, Dispatch const & d ) const
-  {
-    Result result = static_cast<Result>( d.vkImportSemaphoreZirconHandleFUCHSIA(
-      m_device,
-      reinterpret_cast<const VkImportSemaphoreZirconHandleInfoFUCHSIA *>( &importSemaphoreZirconHandleInfo ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importSemaphoreZirconHandleFUCHSIA" );
-  }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_USE_PLATFORM_FUCHSIA*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::initializePerformanceApiINTEL(
-    const VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL * pInitializeInfo,
-    Dispatch const &                                                d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkInitializePerformanceApiINTEL(
-      m_device, reinterpret_cast<const VkInitializePerformanceApiInfoINTEL *>( pInitializeInfo ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
-    Device::initializePerformanceApiINTEL( const InitializePerformanceApiInfoINTEL & initializeInfo,
-                                           Dispatch const &                          d ) const
-  {
-    Result result = static_cast<Result>( d.vkInitializePerformanceApiINTEL(
-      m_device, reinterpret_cast<const VkInitializePerformanceApiInfoINTEL *>( &initializeInfo ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::initializePerformanceApiINTEL" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::invalidateMappedMemoryRanges( uint32_t                                        memoryRangeCount,
-                                          const VULKAN_HPP_NAMESPACE::MappedMemoryRange * pMemoryRanges,
-                                          Dispatch const &                                d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkInvalidateMappedMemoryRanges(
-      m_device, memoryRangeCount, reinterpret_cast<const VkMappedMemoryRange *>( pMemoryRanges ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
-                                          Device::invalidateMappedMemoryRanges(
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges, Dispatch const & d ) const
-  {
-    Result result = static_cast<Result>( d.vkInvalidateMappedMemoryRanges(
-      m_device, memoryRanges.size(), reinterpret_cast<const VkMappedMemoryRange *>( memoryRanges.data() ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::invalidateMappedMemoryRanges" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::mapMemory( VULKAN_HPP_NAMESPACE::DeviceMemory   memory,
-                                                                   VULKAN_HPP_NAMESPACE::DeviceSize     offset,
-                                                                   VULKAN_HPP_NAMESPACE::DeviceSize     size,
-                                                                   VULKAN_HPP_NAMESPACE::MemoryMapFlags flags,
-                                                                   void **                              ppData,
-                                                                   Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkMapMemory( m_device,
-                                               static_cast<VkDeviceMemory>( memory ),
-                                               static_cast<VkDeviceSize>( offset ),
-                                               static_cast<VkDeviceSize>( size ),
-                                               static_cast<VkMemoryMapFlags>( flags ),
-                                               ppData ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void *>::type
-                                          Device::mapMemory( VULKAN_HPP_NAMESPACE::DeviceMemory   memory,
-                       VULKAN_HPP_NAMESPACE::DeviceSize     offset,
-                       VULKAN_HPP_NAMESPACE::DeviceSize     size,
-                       VULKAN_HPP_NAMESPACE::MemoryMapFlags flags,
-                       Dispatch const &                     d ) const
-  {
-    void * pData;
-    Result result = static_cast<Result>( d.vkMapMemory( m_device,
-                                                        static_cast<VkDeviceMemory>( memory ),
-                                                        static_cast<VkDeviceSize>( offset ),
-                                                        static_cast<VkDeviceSize>( size ),
-                                                        static_cast<VkMemoryMapFlags>( flags ),
-                                                        &pData ) );
-    return createResultValue( result, pData, VULKAN_HPP_NAMESPACE_STRING "::Device::mapMemory" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::mergePipelineCaches( VULKAN_HPP_NAMESPACE::PipelineCache         dstCache,
-                                 uint32_t                                    srcCacheCount,
-                                 const VULKAN_HPP_NAMESPACE::PipelineCache * pSrcCaches,
-                                 Dispatch const &                            d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkMergePipelineCaches( m_device,
-                                                         static_cast<VkPipelineCache>( dstCache ),
-                                                         srcCacheCount,
-                                                         reinterpret_cast<const VkPipelineCache *>( pSrcCaches ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
-                                          Device::mergePipelineCaches( VULKAN_HPP_NAMESPACE::PipelineCache                           dstCache,
-                                 ArrayProxy<const VULKAN_HPP_NAMESPACE::PipelineCache> const & srcCaches,
-                                 Dispatch const &                                              d ) const
-  {
-    Result result =
-      static_cast<Result>( d.vkMergePipelineCaches( m_device,
-                                                    static_cast<VkPipelineCache>( dstCache ),
-                                                    srcCaches.size(),
-                                                    reinterpret_cast<const VkPipelineCache *>( srcCaches.data() ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::mergePipelineCaches" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::mergeValidationCachesEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT         dstCache,
-                                      uint32_t                                         srcCacheCount,
-                                      const VULKAN_HPP_NAMESPACE::ValidationCacheEXT * pSrcCaches,
-                                      Dispatch const &                                 d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkMergeValidationCachesEXT( m_device,
-                                    static_cast<VkValidationCacheEXT>( dstCache ),
-                                    srcCacheCount,
-                                    reinterpret_cast<const VkValidationCacheEXT *>( pSrcCaches ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
-    Device::mergeValidationCachesEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT                           dstCache,
-                                      ArrayProxy<const VULKAN_HPP_NAMESPACE::ValidationCacheEXT> const & srcCaches,
-                                      Dispatch const &                                                   d ) const
-  {
-    Result result = static_cast<Result>(
-      d.vkMergeValidationCachesEXT( m_device,
-                                    static_cast<VkValidationCacheEXT>( dstCache ),
-                                    srcCaches.size(),
-                                    reinterpret_cast<const VkValidationCacheEXT *>( srcCaches.data() ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::mergeValidationCachesEXT" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::registerEventEXT( const VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT *  pDeviceEventInfo,
-                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                              VULKAN_HPP_NAMESPACE::Fence *                     pFence,
-                              Dispatch const &                                  d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkRegisterDeviceEventEXT( m_device,
-                                  reinterpret_cast<const VkDeviceEventInfoEXT *>( pDeviceEventInfo ),
-                                  reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
-                                  reinterpret_cast<VkFence *>( pFence ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::Fence>::type
-    Device::registerEventEXT( const DeviceEventInfoEXT &          deviceEventInfo,
-                              Optional<const AllocationCallbacks> allocator,
-                              Dispatch const &                    d ) const
-  {
-    VULKAN_HPP_NAMESPACE::Fence fence;
-    Result                      result = static_cast<Result>(
-      d.vkRegisterDeviceEventEXT( m_device,
-                                  reinterpret_cast<const VkDeviceEventInfoEXT *>( &deviceEventInfo ),
-                                  reinterpret_cast<const VkAllocationCallbacks *>(
-                                    static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                  reinterpret_cast<VkFence *>( &fence ) ) );
-    return createResultValue( result, fence, VULKAN_HPP_NAMESPACE_STRING "::Device::registerEventEXT" );
-  }
-
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>>::type
-    Device::registerEventEXTUnique( const DeviceEventInfoEXT &          deviceEventInfo,
-                                    Optional<const AllocationCallbacks> allocator,
-                                    Dispatch const &                    d ) const
-  {
-    VULKAN_HPP_NAMESPACE::Fence fence;
-    Result                      result = static_cast<Result>(
-      d.vkRegisterDeviceEventEXT( m_device,
-                                  reinterpret_cast<const VkDeviceEventInfoEXT *>( &deviceEventInfo ),
-                                  reinterpret_cast<const VkAllocationCallbacks *>(
-                                    static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                  reinterpret_cast<VkFence *>( &fence ) ) );
-    ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<VULKAN_HPP_NAMESPACE::Fence, Dispatch>(
-      result, fence, VULKAN_HPP_NAMESPACE_STRING "::Device::registerEventEXTUnique", deleter );
-  }
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::registerDisplayEventEXT( VULKAN_HPP_NAMESPACE::DisplayKHR                  display,
-                                     const VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT * pDisplayEventInfo,
-                                     const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                     VULKAN_HPP_NAMESPACE::Fence *                     pFence,
-                                     Dispatch const &                                  d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkRegisterDisplayEventEXT( m_device,
-                                   static_cast<VkDisplayKHR>( display ),
-                                   reinterpret_cast<const VkDisplayEventInfoEXT *>( pDisplayEventInfo ),
-                                   reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
-                                   reinterpret_cast<VkFence *>( pFence ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::Fence>::type
-    Device::registerDisplayEventEXT( VULKAN_HPP_NAMESPACE::DisplayKHR    display,
-                                     const DisplayEventInfoEXT &         displayEventInfo,
-                                     Optional<const AllocationCallbacks> allocator,
-                                     Dispatch const &                    d ) const
-  {
-    VULKAN_HPP_NAMESPACE::Fence fence;
-    Result                      result = static_cast<Result>(
-      d.vkRegisterDisplayEventEXT( m_device,
-                                   static_cast<VkDisplayKHR>( display ),
-                                   reinterpret_cast<const VkDisplayEventInfoEXT *>( &displayEventInfo ),
-                                   reinterpret_cast<const VkAllocationCallbacks *>(
-                                     static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                   reinterpret_cast<VkFence *>( &fence ) ) );
-    return createResultValue( result, fence, VULKAN_HPP_NAMESPACE_STRING "::Device::registerDisplayEventEXT" );
-  }
-
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>>::type
-    Device::registerDisplayEventEXTUnique( VULKAN_HPP_NAMESPACE::DisplayKHR    display,
-                                           const DisplayEventInfoEXT &         displayEventInfo,
-                                           Optional<const AllocationCallbacks> allocator,
-                                           Dispatch const &                    d ) const
-  {
-    VULKAN_HPP_NAMESPACE::Fence fence;
-    Result                      result = static_cast<Result>(
-      d.vkRegisterDisplayEventEXT( m_device,
-                                   static_cast<VkDisplayKHR>( display ),
-                                   reinterpret_cast<const VkDisplayEventInfoEXT *>( &displayEventInfo ),
-                                   reinterpret_cast<const VkAllocationCallbacks *>(
-                                     static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                   reinterpret_cast<VkFence *>( &fence ) ) );
-    ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<VULKAN_HPP_NAMESPACE::Fence, Dispatch>(
-      result, fence, VULKAN_HPP_NAMESPACE_STRING "::Device::registerDisplayEventEXTUnique", deleter );
-  }
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#if defined( VK_USE_PLATFORM_WIN32_KHR )
-#  ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::releaseFullScreenExclusiveModeEXT(
-    VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkReleaseFullScreenExclusiveModeEXT( m_device, static_cast<VkSwapchainKHR>( swapchain ) ) );
-  }
-#  else
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
-    Device::releaseFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d ) const
-  {
-    Result result = static_cast<Result>(
-      d.vkReleaseFullScreenExclusiveModeEXT( m_device, static_cast<VkSwapchainKHR>( swapchain ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::releaseFullScreenExclusiveModeEXT" );
-  }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::releasePerformanceConfigurationINTEL(
-    VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkReleasePerformanceConfigurationINTEL(
-      m_device, static_cast<VkPerformanceConfigurationINTEL>( configuration ) ) );
-  }
-#else
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
-    Device::releasePerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,
-                                                  Dispatch const & d ) const
-  {
-    Result result = static_cast<Result>( d.vkReleasePerformanceConfigurationINTEL(
-      m_device, static_cast<VkPerformanceConfigurationINTEL>( configuration ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::releasePerformanceConfigurationINTEL" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::release(
-    VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkReleasePerformanceConfigurationINTEL(
-      m_device, static_cast<VkPerformanceConfigurationINTEL>( configuration ) ) );
-  }
-#else
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
-    Device::release( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration, Dispatch const & d ) const
-  {
-    Result result = static_cast<Result>( d.vkReleasePerformanceConfigurationINTEL(
-      m_device, static_cast<VkPerformanceConfigurationINTEL>( configuration ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::release" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::releaseProfilingLockKHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkReleaseProfilingLockKHR( m_device );
-  }
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::resetCommandPool( VULKAN_HPP_NAMESPACE::CommandPool           commandPool,
-                              VULKAN_HPP_NAMESPACE::CommandPoolResetFlags flags,
-                              Dispatch const &                            d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkResetCommandPool(
-      m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolResetFlags>( flags ) ) );
-  }
-#else
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<void>::type
-    Device::resetCommandPool( VULKAN_HPP_NAMESPACE::CommandPool commandPool,
-                              VULKAN_HPP_NAMESPACE::CommandPoolResetFlags flags,
-                              Dispatch const & d ) const
-  {
-    Result result = static_cast<Result>( d.vkResetCommandPool(
-      m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolResetFlags>( flags ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::resetCommandPool" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::resetDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool           descriptorPool,
-                                                        VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags,
-                                                        Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkResetDescriptorPool(
-      m_device, static_cast<VkDescriptorPool>( descriptorPool ), static_cast<VkDescriptorPoolResetFlags>( flags ) ) );
-  }
-#else
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<void>::type
-    Device::resetDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool,
-                                 VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags,
-                                 Dispatch const & d ) const
-  {
-    Result result = static_cast<Result>( d.vkResetDescriptorPool(
-      m_device, static_cast<VkDescriptorPool>( descriptorPool ), static_cast<VkDescriptorPoolResetFlags>( flags ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::resetDescriptorPool" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::resetEvent( VULKAN_HPP_NAMESPACE::Event event,
-                                                                    Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkResetEvent( m_device, static_cast<VkEvent>( event ) ) );
-  }
-#else
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::resetEvent( VULKAN_HPP_NAMESPACE::Event event,
-                                                                             Dispatch const & d ) const
-  {
-    Result result = static_cast<Result>( d.vkResetEvent( m_device, static_cast<VkEvent>( event ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::resetEvent" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::resetFences( uint32_t                            fenceCount,
-                                                                     const VULKAN_HPP_NAMESPACE::Fence * pFences,
-                                                                     Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkResetFences( m_device, fenceCount, reinterpret_cast<const VkFence *>( pFences ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<void>::type
-    Device::resetFences( ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences, Dispatch const & d ) const
-  {
-    Result result = static_cast<Result>(
-      d.vkResetFences( m_device, fences.size(), reinterpret_cast<const VkFence *>( fences.data() ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::resetFences" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::resetQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
-                                                 uint32_t                        firstQuery,
-                                                 uint32_t                        queryCount,
-                                                 Dispatch const &                d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkResetQueryPool( m_device, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::resetQueryPoolEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
-                                                    uint32_t                        firstQuery,
-                                                    uint32_t                        queryCount,
-                                                    Dispatch const &                d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkResetQueryPoolEXT( m_device, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::setDebugUtilsObjectNameEXT(
-    const VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT * pNameInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkSetDebugUtilsObjectNameEXT(
-      m_device, reinterpret_cast<const VkDebugUtilsObjectNameInfoEXT *>( pNameInfo ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
-    Device::setDebugUtilsObjectNameEXT( const DebugUtilsObjectNameInfoEXT & nameInfo, Dispatch const & d ) const
-  {
-    Result result = static_cast<Result>( d.vkSetDebugUtilsObjectNameEXT(
-      m_device, reinterpret_cast<const VkDebugUtilsObjectNameInfoEXT *>( &nameInfo ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setDebugUtilsObjectNameEXT" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::setDebugUtilsObjectTagEXT(
-    const VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT * pTagInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkSetDebugUtilsObjectTagEXT( m_device, reinterpret_cast<const VkDebugUtilsObjectTagInfoEXT *>( pTagInfo ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
-    Device::setDebugUtilsObjectTagEXT( const DebugUtilsObjectTagInfoEXT & tagInfo, Dispatch const & d ) const
-  {
-    Result result = static_cast<Result>(
-      d.vkSetDebugUtilsObjectTagEXT( m_device, reinterpret_cast<const VkDebugUtilsObjectTagInfoEXT *>( &tagInfo ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setDebugUtilsObjectTagEXT" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::setEvent( VULKAN_HPP_NAMESPACE::Event event,
+  VULKAN_HPP_INLINE void CommandBuffer::setPatchControlPointsEXT( uint32_t         patchControlPoints,
                                                                   Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
-    return static_cast<Result>( d.vkSetEvent( m_device, static_cast<VkEvent>( event ) ) );
-  }
-#else
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
-    Device::setEvent( VULKAN_HPP_NAMESPACE::Event event, Dispatch const & d ) const
-  {
-    Result result = static_cast<Result>( d.vkSetEvent( m_device, static_cast<VkEvent>( event ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setEvent" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::setHdrMetadataEXT( uint32_t                                     swapchainCount,
-                                                    const VULKAN_HPP_NAMESPACE::SwapchainKHR *   pSwapchains,
-                                                    const VULKAN_HPP_NAMESPACE::HdrMetadataEXT * pMetadata,
-                                                    Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkSetHdrMetadataEXT( m_device,
-                           swapchainCount,
-                           reinterpret_cast<const VkSwapchainKHR *>( pSwapchains ),
-                           reinterpret_cast<const VkHdrMetadataEXT *>( pMetadata ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    Device::setHdrMetadataEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainKHR> const &   swapchains,
-                               ArrayProxy<const VULKAN_HPP_NAMESPACE::HdrMetadataEXT> const & metadata,
-                               Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
-  {
-#  ifdef VULKAN_HPP_NO_EXCEPTIONS
-    VULKAN_HPP_ASSERT( swapchains.size() == metadata.size() );
-#  else
-    if ( swapchains.size() != metadata.size() )
-    {
-      throw LogicError( VULKAN_HPP_NAMESPACE_STRING
-                        "::Device::setHdrMetadataEXT: swapchains.size() != metadata.size()" );
-    }
-#  endif /*VULKAN_HPP_NO_EXCEPTIONS*/
-
-    d.vkSetHdrMetadataEXT( m_device,
-                           swapchains.size(),
-                           reinterpret_cast<const VkSwapchainKHR *>( swapchains.data() ),
-                           reinterpret_cast<const VkHdrMetadataEXT *>( metadata.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::setLocalDimmingAMD( VULKAN_HPP_NAMESPACE::SwapchainKHR swapChain,
-                                                     VULKAN_HPP_NAMESPACE::Bool32       localDimmingEnable,
-                                                     Dispatch const &                   d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkSetLocalDimmingAMD(
-      m_device, static_cast<VkSwapchainKHR>( swapChain ), static_cast<VkBool32>( localDimmingEnable ) );
-  }
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType         objectType,
-                               uint64_t                                 objectHandle,
-                               VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot,
-                               uint64_t                                 data,
-                               Dispatch const &                         d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkSetPrivateDataEXT( m_device,
-                                                       static_cast<VkObjectType>( objectType ),
-                                                       objectHandle,
-                                                       static_cast<VkPrivateDataSlotEXT>( privateDataSlot ),
-                                                       data ) );
-  }
-#else
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<void>::type
-    Device::setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType objectType,
-                               uint64_t objectHandle,
-                               VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot,
-                               uint64_t data,
-                               Dispatch const & d ) const
-  {
-    Result result = static_cast<Result>( d.vkSetPrivateDataEXT( m_device,
-                                                                static_cast<VkObjectType>( objectType ),
-                                                                objectHandle,
-                                                                static_cast<VkPrivateDataSlotEXT>( privateDataSlot ),
-                                                                data ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setPrivateDataEXT" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::signalSemaphore(
-    const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo * pSignalInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkSignalSemaphore( m_device, reinterpret_cast<const VkSemaphoreSignalInfo *>( pSignalInfo ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
-    Device::signalSemaphore( const SemaphoreSignalInfo & signalInfo, Dispatch const & d ) const
-  {
-    Result result = static_cast<Result>(
-      d.vkSignalSemaphore( m_device, reinterpret_cast<const VkSemaphoreSignalInfo *>( &signalInfo ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::signalSemaphore" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::signalSemaphoreKHR(
-    const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo * pSignalInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkSignalSemaphoreKHR( m_device, reinterpret_cast<const VkSemaphoreSignalInfo *>( pSignalInfo ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
-    Device::signalSemaphoreKHR( const SemaphoreSignalInfo & signalInfo, Dispatch const & d ) const
-  {
-    Result result = static_cast<Result>(
-      d.vkSignalSemaphoreKHR( m_device, reinterpret_cast<const VkSemaphoreSignalInfo *>( &signalInfo ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::signalSemaphoreKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::trimCommandPool( VULKAN_HPP_NAMESPACE::CommandPool          commandPool,
-                                                  VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags,
-                                                  Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkTrimCommandPool(
-      m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolTrimFlags>( flags ) );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::trimCommandPoolKHR( VULKAN_HPP_NAMESPACE::CommandPool          commandPool,
-                                                     VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags,
-                                                     Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkTrimCommandPoolKHR(
-      m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolTrimFlags>( flags ) );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::uninitializePerformanceApiINTEL( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkUninitializePerformanceApiINTEL( m_device );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::unmapMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory,
-                                              Dispatch const &                   d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkUnmapMemory( m_device, static_cast<VkDeviceMemory>( memory ) );
+    d.vkCmdSetPatchControlPointsEXT( m_commandBuffer, patchControlPoints );
   }
 
   template <typename Dispatch>
   VULKAN_HPP_INLINE void
-    Device::updateDescriptorSetWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorSet            descriptorSet,
-                                             VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
-                                             const void *                                   pData,
-                                             Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+    CommandBuffer::setRasterizerDiscardEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable,
+                                                  Dispatch const &             d ) const VULKAN_HPP_NOEXCEPT
   {
-    d.vkUpdateDescriptorSetWithTemplate( m_device,
-                                         static_cast<VkDescriptorSet>( descriptorSet ),
-                                         static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
-                                         pData );
+    d.vkCmdSetRasterizerDiscardEnableEXT( m_commandBuffer, static_cast<VkBool32>( rasterizerDiscardEnable ) );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setDepthBiasEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable,
+                                                               Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetDepthBiasEnableEXT( m_commandBuffer, static_cast<VkBool32>( depthBiasEnable ) );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setLogicOpEXT( VULKAN_HPP_NAMESPACE::LogicOp logicOp,
+                                                       Dispatch const &              d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetLogicOpEXT( m_commandBuffer, static_cast<VkLogicOp>( logicOp ) );
   }
 
   template <typename Dispatch>
   VULKAN_HPP_INLINE void
-    Device::updateDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorSet            descriptorSet,
-                                                VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
-                                                const void *                                   pData,
-                                                Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+    CommandBuffer::setPrimitiveRestartEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable,
+                                                 Dispatch const &             d ) const VULKAN_HPP_NOEXCEPT
   {
-    d.vkUpdateDescriptorSetWithTemplateKHR( m_device,
-                                            static_cast<VkDescriptorSet>( descriptorSet ),
-                                            static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
-                                            pData );
+    d.vkCmdSetPrimitiveRestartEnableEXT( m_commandBuffer, static_cast<VkBool32>( primitiveRestartEnable ) );
   }
 
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    Device::updateDescriptorSets( uint32_t                                         descriptorWriteCount,
-                                  const VULKAN_HPP_NAMESPACE::WriteDescriptorSet * pDescriptorWrites,
-                                  uint32_t                                         descriptorCopyCount,
-                                  const VULKAN_HPP_NAMESPACE::CopyDescriptorSet *  pDescriptorCopies,
-                                  Dispatch const &                                 d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkUpdateDescriptorSets( m_device,
-                              descriptorWriteCount,
-                              reinterpret_cast<const VkWriteDescriptorSet *>( pDescriptorWrites ),
-                              descriptorCopyCount,
-                              reinterpret_cast<const VkCopyDescriptorSet *>( pDescriptorCopies ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    Device::updateDescriptorSets( ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites,
-                                  ArrayProxy<const VULKAN_HPP_NAMESPACE::CopyDescriptorSet> const &  descriptorCopies,
-                                  Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkUpdateDescriptorSets( m_device,
-                              descriptorWrites.size(),
-                              reinterpret_cast<const VkWriteDescriptorSet *>( descriptorWrites.data() ),
-                              descriptorCopies.size(),
-                              reinterpret_cast<const VkCopyDescriptorSet *>( descriptorCopies.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#if defined( VK_ENABLE_BETA_EXTENSIONS )
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::updateVideoSessionParametersKHR(
-    VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR                   videoSessionParameters,
-    const VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR * pUpdateInfo,
-    Dispatch const &                                                  d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkUpdateVideoSessionParametersKHR(
-      m_device,
-      static_cast<VkVideoSessionParametersKHR>( videoSessionParameters ),
-      reinterpret_cast<const VkVideoSessionParametersUpdateInfoKHR *>( pUpdateInfo ) ) );
-  }
-
-#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
-    Device::updateVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters,
-                                             const VideoSessionParametersUpdateInfoKHR &     updateInfo,
-                                             Dispatch const &                                d ) const
-  {
-    Result result = static_cast<Result>( d.vkUpdateVideoSessionParametersKHR(
-      m_device,
-      static_cast<VkVideoSessionParametersKHR>( videoSessionParameters ),
-      reinterpret_cast<const VkVideoSessionParametersUpdateInfoKHR *>( &updateInfo ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::updateVideoSessionParametersKHR" );
-  }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_ENABLE_BETA_EXTENSIONS*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::waitForFences( uint32_t                            fenceCount,
-                                                                       const VULKAN_HPP_NAMESPACE::Fence * pFences,
-                                                                       VULKAN_HPP_NAMESPACE::Bool32        waitAll,
-                                                                       uint64_t                            timeout,
-                                                                       Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkWaitForFences(
-      m_device, fenceCount, reinterpret_cast<const VkFence *>( pFences ), static_cast<VkBool32>( waitAll ), timeout ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::waitForFences( ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences,
-                           VULKAN_HPP_NAMESPACE::Bool32                          waitAll,
-                           uint64_t                                              timeout,
-                           Dispatch const &                                      d ) const
-  {
-    Result result = static_cast<Result>( d.vkWaitForFences( m_device,
-                                                            fences.size(),
-                                                            reinterpret_cast<const VkFence *>( fences.data() ),
-                                                            static_cast<VkBool32>( waitAll ),
-                                                            timeout ) );
-    return createResultValue( result,
-                              VULKAN_HPP_NAMESPACE_STRING "::Device::waitForFences",
-                              { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eTimeout } );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::waitSemaphores( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo * pWaitInfo,
-                            uint64_t                                        timeout,
-                            Dispatch const &                                d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkWaitSemaphores( m_device, reinterpret_cast<const VkSemaphoreWaitInfo *>( pWaitInfo ), timeout ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::waitSemaphores( const SemaphoreWaitInfo & waitInfo,
-                                                                        uint64_t                  timeout,
-                                                                        Dispatch const &          d ) const
-  {
-    Result result = static_cast<Result>(
-      d.vkWaitSemaphores( m_device, reinterpret_cast<const VkSemaphoreWaitInfo *>( &waitInfo ), timeout ) );
-    return createResultValue( result,
-                              VULKAN_HPP_NAMESPACE_STRING "::Device::waitSemaphores",
-                              { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eTimeout } );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Device::waitSemaphoresKHR( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo * pWaitInfo,
-                               uint64_t                                        timeout,
-                               Dispatch const &                                d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkWaitSemaphoresKHR( m_device, reinterpret_cast<const VkSemaphoreWaitInfo *>( pWaitInfo ), timeout ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::waitSemaphoresKHR( const SemaphoreWaitInfo & waitInfo,
-                                                                           uint64_t                  timeout,
-                                                                           Dispatch const &          d ) const
-  {
-    Result result = static_cast<Result>(
-      d.vkWaitSemaphoresKHR( m_device, reinterpret_cast<const VkSemaphoreWaitInfo *>( &waitInfo ), timeout ) );
-    return createResultValue( result,
-                              VULKAN_HPP_NAMESPACE_STRING "::Device::waitSemaphoresKHR",
-                              { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eTimeout } );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::writeAccelerationStructuresPropertiesKHR(
-    uint32_t                                               accelerationStructureCount,
-    const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR * pAccelerationStructures,
-    VULKAN_HPP_NAMESPACE::QueryType                        queryType,
-    size_t                                                 dataSize,
-    void *                                                 pData,
-    size_t                                                 stride,
-    Dispatch const &                                       d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkWriteAccelerationStructuresPropertiesKHR(
-      m_device,
-      accelerationStructureCount,
-      reinterpret_cast<const VkAccelerationStructureKHR *>( pAccelerationStructures ),
-      static_cast<VkQueryType>( queryType ),
-      dataSize,
-      pData,
-      stride ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename T, typename Dispatch>
-  VULKAN_HPP_DEPRECATED( "This function is deprecated. Use one of the other flavours of it." )
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<void>::type Device::writeAccelerationStructuresPropertiesKHR(
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
-      VULKAN_HPP_NAMESPACE::QueryType                                          queryType,
-      ArrayProxy<T> const &                                                    data,
-      size_t                                                                   stride,
-      Dispatch const &                                                         d ) const
-  {
-    Result result = static_cast<Result>( d.vkWriteAccelerationStructuresPropertiesKHR(
-      m_device,
-      accelerationStructures.size(),
-      reinterpret_cast<const VkAccelerationStructureKHR *>( accelerationStructures.data() ),
-      static_cast<VkQueryType>( queryType ),
-      data.size() * sizeof( T ),
-      reinterpret_cast<void *>( data.data() ),
-      stride ) );
-    return createResultValue( result,
-                              VULKAN_HPP_NAMESPACE_STRING "::Device::writeAccelerationStructuresPropertiesKHR" );
-  }
-
-  template <typename T, typename Allocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<std::vector<T, Allocator>>::type
-                                          Device::writeAccelerationStructuresPropertiesKHR(
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
-      VULKAN_HPP_NAMESPACE::QueryType                                          queryType,
-      size_t                                                                   dataSize,
-      size_t                                                                   stride,
-      Dispatch const &                                                         d ) const
-  {
-    VULKAN_HPP_ASSERT( dataSize % sizeof( T ) == 0 );
-    std::vector<T, Allocator> data( dataSize / sizeof( T ) );
-    Result                    result = static_cast<Result>( d.vkWriteAccelerationStructuresPropertiesKHR(
-      m_device,
-      accelerationStructures.size(),
-      reinterpret_cast<const VkAccelerationStructureKHR *>( accelerationStructures.data() ),
-      static_cast<VkQueryType>( queryType ),
-      data.size() * sizeof( T ),
-      reinterpret_cast<void *>( data.data() ),
-      stride ) );
-    return createResultValue(
-      result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::writeAccelerationStructuresPropertiesKHR" );
-  }
-
-  template <typename T, typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<T>::type
-                                          Device::writeAccelerationStructuresPropertyKHR(
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
-      VULKAN_HPP_NAMESPACE::QueryType                                          queryType,
-      size_t                                                                   stride,
-      Dispatch const &                                                         d ) const
-  {
-    T      data;
-    Result result = static_cast<Result>( d.vkWriteAccelerationStructuresPropertiesKHR(
-      m_device,
-      accelerationStructures.size(),
-      reinterpret_cast<const VkAccelerationStructureKHR *>( accelerationStructures.data() ),
-      static_cast<VkQueryType>( queryType ),
-      sizeof( T ),
-      reinterpret_cast<void *>( &data ),
-      stride ) );
-    return createResultValue(
-      result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::writeAccelerationStructuresPropertyKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#if defined( VK_USE_PLATFORM_ANDROID_KHR )
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Instance::createAndroidSurfaceKHR( const VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR * pCreateInfo,
-                                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *         pAllocator,
-                                       VULKAN_HPP_NAMESPACE::SurfaceKHR *                        pSurface,
-                                       Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkCreateAndroidSurfaceKHR( m_instance,
-                                   reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR *>( pCreateInfo ),
-                                   reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
-                                   reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
-  }
-
-#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
-    Instance::createAndroidSurfaceKHR( const AndroidSurfaceCreateInfoKHR & createInfo,
-                                       Optional<const AllocationCallbacks> allocator,
-                                       Dispatch const &                    d ) const
-  {
-    VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
-    Result                           result = static_cast<Result>(
-      d.vkCreateAndroidSurfaceKHR( m_instance,
-                                   reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR *>( &createInfo ),
-                                   reinterpret_cast<const VkAllocationCallbacks *>(
-                                     static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                   reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
-    return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createAndroidSurfaceKHR" );
-  }
-
-#    ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
-    Instance::createAndroidSurfaceKHRUnique( const AndroidSurfaceCreateInfoKHR & createInfo,
-                                             Optional<const AllocationCallbacks> allocator,
-                                             Dispatch const &                    d ) const
-  {
-    VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
-    Result                           result = static_cast<Result>(
-      d.vkCreateAndroidSurfaceKHR( m_instance,
-                                   reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR *>( &createInfo ),
-                                   reinterpret_cast<const VkAllocationCallbacks *>(
-                                     static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                   reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
-    ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>(
-      result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createAndroidSurfaceKHRUnique", deleter );
-  }
-#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif     /*VK_USE_PLATFORM_ANDROID_KHR*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Instance::createDebugReportCallbackEXT( const VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT * pCreateInfo,
-                                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks *              pAllocator,
-                                            VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT *                 pCallback,
-                                            Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkCreateDebugReportCallbackEXT( m_instance,
-                                        reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT *>( pCreateInfo ),
-                                        reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
-                                        reinterpret_cast<VkDebugReportCallbackEXT *>( pCallback ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT>::type
-    Instance::createDebugReportCallbackEXT( const DebugReportCallbackCreateInfoEXT & createInfo,
-                                            Optional<const AllocationCallbacks>      allocator,
-                                            Dispatch const &                         d ) const
-  {
-    VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback;
-    Result                                       result = static_cast<Result>(
-      d.vkCreateDebugReportCallbackEXT( m_instance,
-                                        reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT *>( &createInfo ),
-                                        reinterpret_cast<const VkAllocationCallbacks *>(
-                                          static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                        reinterpret_cast<VkDebugReportCallbackEXT *>( &callback ) ) );
-    return createResultValue(
-      result, callback, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDebugReportCallbackEXT" );
-  }
-
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT, Dispatch>>::type
-    Instance::createDebugReportCallbackEXTUnique( const DebugReportCallbackCreateInfoEXT & createInfo,
-                                                  Optional<const AllocationCallbacks>      allocator,
-                                                  Dispatch const &                         d ) const
-  {
-    VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback;
-    Result                                       result = static_cast<Result>(
-      d.vkCreateDebugReportCallbackEXT( m_instance,
-                                        reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT *>( &createInfo ),
-                                        reinterpret_cast<const VkAllocationCallbacks *>(
-                                          static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                        reinterpret_cast<VkDebugReportCallbackEXT *>( &callback ) ) );
-    ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT, Dispatch>(
-      result, callback, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDebugReportCallbackEXTUnique", deleter );
-  }
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Instance::createDebugUtilsMessengerEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT * pCreateInfo,
-                                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks *              pAllocator,
-                                            VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT *                 pMessenger,
-                                            Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkCreateDebugUtilsMessengerEXT( m_instance,
-                                        reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT *>( pCreateInfo ),
-                                        reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
-                                        reinterpret_cast<VkDebugUtilsMessengerEXT *>( pMessenger ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT>::type
-    Instance::createDebugUtilsMessengerEXT( const DebugUtilsMessengerCreateInfoEXT & createInfo,
-                                            Optional<const AllocationCallbacks>      allocator,
-                                            Dispatch const &                         d ) const
-  {
-    VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger;
-    Result                                       result = static_cast<Result>(
-      d.vkCreateDebugUtilsMessengerEXT( m_instance,
-                                        reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT *>( &createInfo ),
-                                        reinterpret_cast<const VkAllocationCallbacks *>(
-                                          static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                        reinterpret_cast<VkDebugUtilsMessengerEXT *>( &messenger ) ) );
-    return createResultValue(
-      result, messenger, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDebugUtilsMessengerEXT" );
-  }
-
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT, Dispatch>>::type
-    Instance::createDebugUtilsMessengerEXTUnique( const DebugUtilsMessengerCreateInfoEXT & createInfo,
-                                                  Optional<const AllocationCallbacks>      allocator,
-                                                  Dispatch const &                         d ) const
-  {
-    VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger;
-    Result                                       result = static_cast<Result>(
-      d.vkCreateDebugUtilsMessengerEXT( m_instance,
-                                        reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT *>( &createInfo ),
-                                        reinterpret_cast<const VkAllocationCallbacks *>(
-                                          static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                        reinterpret_cast<VkDebugUtilsMessengerEXT *>( &messenger ) ) );
-    ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT, Dispatch>(
-      result, messenger, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDebugUtilsMessengerEXTUnique", deleter );
-  }
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Instance::createDirectFBSurfaceEXT( const VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT * pCreateInfo,
-                                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks *          pAllocator,
-                                        VULKAN_HPP_NAMESPACE::SurfaceKHR *                         pSurface,
-                                        Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkCreateDirectFBSurfaceEXT( m_instance,
-                                    reinterpret_cast<const VkDirectFBSurfaceCreateInfoEXT *>( pCreateInfo ),
-                                    reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
-                                    reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
-  }
-
-#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
-    Instance::createDirectFBSurfaceEXT( const DirectFBSurfaceCreateInfoEXT & createInfo,
-                                        Optional<const AllocationCallbacks>  allocator,
-                                        Dispatch const &                     d ) const
-  {
-    VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
-    Result                           result = static_cast<Result>(
-      d.vkCreateDirectFBSurfaceEXT( m_instance,
-                                    reinterpret_cast<const VkDirectFBSurfaceCreateInfoEXT *>( &createInfo ),
-                                    reinterpret_cast<const VkAllocationCallbacks *>(
-                                      static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                    reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
-    return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDirectFBSurfaceEXT" );
-  }
-
-#    ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
-    Instance::createDirectFBSurfaceEXTUnique( const DirectFBSurfaceCreateInfoEXT & createInfo,
-                                              Optional<const AllocationCallbacks>  allocator,
-                                              Dispatch const &                     d ) const
-  {
-    VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
-    Result                           result = static_cast<Result>(
-      d.vkCreateDirectFBSurfaceEXT( m_instance,
-                                    reinterpret_cast<const VkDirectFBSurfaceCreateInfoEXT *>( &createInfo ),
-                                    reinterpret_cast<const VkAllocationCallbacks *>(
-                                      static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                    reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
-    ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>(
-      result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDirectFBSurfaceEXTUnique", deleter );
-  }
-#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif     /*VK_USE_PLATFORM_DIRECTFB_EXT*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Instance::createDisplayPlaneSurfaceKHR( const VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR * pCreateInfo,
-                                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks *         pAllocator,
-                                            VULKAN_HPP_NAMESPACE::SurfaceKHR *                        pSurface,
-                                            Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkCreateDisplayPlaneSurfaceKHR( m_instance,
-                                        reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR *>( pCreateInfo ),
-                                        reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
-                                        reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
-    Instance::createDisplayPlaneSurfaceKHR( const DisplaySurfaceCreateInfoKHR & createInfo,
-                                            Optional<const AllocationCallbacks> allocator,
-                                            Dispatch const &                    d ) const
-  {
-    VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
-    Result                           result = static_cast<Result>(
-      d.vkCreateDisplayPlaneSurfaceKHR( m_instance,
-                                        reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR *>( &createInfo ),
-                                        reinterpret_cast<const VkAllocationCallbacks *>(
-                                          static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                        reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
-    return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDisplayPlaneSurfaceKHR" );
-  }
-
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
-    Instance::createDisplayPlaneSurfaceKHRUnique( const DisplaySurfaceCreateInfoKHR & createInfo,
-                                                  Optional<const AllocationCallbacks> allocator,
-                                                  Dispatch const &                    d ) const
-  {
-    VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
-    Result                           result = static_cast<Result>(
-      d.vkCreateDisplayPlaneSurfaceKHR( m_instance,
-                                        reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR *>( &createInfo ),
-                                        reinterpret_cast<const VkAllocationCallbacks *>(
-                                          static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                        reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
-    ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>(
-      result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDisplayPlaneSurfaceKHRUnique", deleter );
-  }
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Instance::createHeadlessSurfaceEXT( const VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT * pCreateInfo,
-                                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks *          pAllocator,
-                                        VULKAN_HPP_NAMESPACE::SurfaceKHR *                         pSurface,
-                                        Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkCreateHeadlessSurfaceEXT( m_instance,
-                                    reinterpret_cast<const VkHeadlessSurfaceCreateInfoEXT *>( pCreateInfo ),
-                                    reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
-                                    reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
-    Instance::createHeadlessSurfaceEXT( const HeadlessSurfaceCreateInfoEXT & createInfo,
-                                        Optional<const AllocationCallbacks>  allocator,
-                                        Dispatch const &                     d ) const
-  {
-    VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
-    Result                           result = static_cast<Result>(
-      d.vkCreateHeadlessSurfaceEXT( m_instance,
-                                    reinterpret_cast<const VkHeadlessSurfaceCreateInfoEXT *>( &createInfo ),
-                                    reinterpret_cast<const VkAllocationCallbacks *>(
-                                      static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                    reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
-    return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createHeadlessSurfaceEXT" );
-  }
-
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
-    Instance::createHeadlessSurfaceEXTUnique( const HeadlessSurfaceCreateInfoEXT & createInfo,
-                                              Optional<const AllocationCallbacks>  allocator,
-                                              Dispatch const &                     d ) const
-  {
-    VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
-    Result                           result = static_cast<Result>(
-      d.vkCreateHeadlessSurfaceEXT( m_instance,
-                                    reinterpret_cast<const VkHeadlessSurfaceCreateInfoEXT *>( &createInfo ),
-                                    reinterpret_cast<const VkAllocationCallbacks *>(
-                                      static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                    reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
-    ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>(
-      result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createHeadlessSurfaceEXTUnique", deleter );
-  }
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#if defined( VK_USE_PLATFORM_IOS_MVK )
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Instance::createIOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK * pCreateInfo,
-                                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks *     pAllocator,
-                                   VULKAN_HPP_NAMESPACE::SurfaceKHR *                    pSurface,
-                                   Dispatch const &                                      d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkCreateIOSSurfaceMVK( m_instance,
-                               reinterpret_cast<const VkIOSSurfaceCreateInfoMVK *>( pCreateInfo ),
-                               reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
-                               reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
-  }
-
-#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
-    Instance::createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK &     createInfo,
-                                   Optional<const AllocationCallbacks> allocator,
-                                   Dispatch const &                    d ) const
-  {
-    VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
-    Result                           result = static_cast<Result>(
-      d.vkCreateIOSSurfaceMVK( m_instance,
-                               reinterpret_cast<const VkIOSSurfaceCreateInfoMVK *>( &createInfo ),
-                               reinterpret_cast<const VkAllocationCallbacks *>(
-                                 static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                               reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
-    return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createIOSSurfaceMVK" );
-  }
-
-#    ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
-    Instance::createIOSSurfaceMVKUnique( const IOSSurfaceCreateInfoMVK &     createInfo,
-                                         Optional<const AllocationCallbacks> allocator,
-                                         Dispatch const &                    d ) const
-  {
-    VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
-    Result                           result = static_cast<Result>(
-      d.vkCreateIOSSurfaceMVK( m_instance,
-                               reinterpret_cast<const VkIOSSurfaceCreateInfoMVK *>( &createInfo ),
-                               reinterpret_cast<const VkAllocationCallbacks *>(
-                                 static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                               reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
-    ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>(
-      result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createIOSSurfaceMVKUnique", deleter );
-  }
-#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif     /*VK_USE_PLATFORM_IOS_MVK*/
-
-#if defined( VK_USE_PLATFORM_FUCHSIA )
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createImagePipeSurfaceFUCHSIA(
-    const VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA * pCreateInfo,
-    const VULKAN_HPP_NAMESPACE::AllocationCallbacks *               pAllocator,
-    VULKAN_HPP_NAMESPACE::SurfaceKHR *                              pSurface,
-    Dispatch const &                                                d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkCreateImagePipeSurfaceFUCHSIA( m_instance,
-                                         reinterpret_cast<const VkImagePipeSurfaceCreateInfoFUCHSIA *>( pCreateInfo ),
-                                         reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
-                                         reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
-  }
-
-#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
-    Instance::createImagePipeSurfaceFUCHSIA( const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo,
-                                             Optional<const AllocationCallbacks>       allocator,
-                                             Dispatch const &                          d ) const
-  {
-    VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
-    Result                           result = static_cast<Result>( d.vkCreateImagePipeSurfaceFUCHSIA(
-      m_instance,
-      reinterpret_cast<const VkImagePipeSurfaceCreateInfoFUCHSIA *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>(
-        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
-    return createResultValue(
-      result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createImagePipeSurfaceFUCHSIA" );
-  }
-
-#    ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
-    Instance::createImagePipeSurfaceFUCHSIAUnique( const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo,
-                                                   Optional<const AllocationCallbacks>       allocator,
-                                                   Dispatch const &                          d ) const
-  {
-    VULKAN_HPP_NAMESPACE::SurfaceKHR  surface;
-    Result                            result = static_cast<Result>( d.vkCreateImagePipeSurfaceFUCHSIA(
-      m_instance,
-      reinterpret_cast<const VkImagePipeSurfaceCreateInfoFUCHSIA *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>(
-        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
-    ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>(
-      result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createImagePipeSurfaceFUCHSIAUnique", deleter );
-  }
-#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif     /*VK_USE_PLATFORM_FUCHSIA*/
-
-#if defined( VK_USE_PLATFORM_MACOS_MVK )
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Instance::createMacOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK * pCreateInfo,
-                                     const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,
-                                     VULKAN_HPP_NAMESPACE::SurfaceKHR *                      pSurface,
-                                     Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkCreateMacOSSurfaceMVK( m_instance,
-                                 reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK *>( pCreateInfo ),
-                                 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
-                                 reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
-  }
-
-#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
-    Instance::createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK &   createInfo,
-                                     Optional<const AllocationCallbacks> allocator,
-                                     Dispatch const &                    d ) const
-  {
-    VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
-    Result                           result = static_cast<Result>(
-      d.vkCreateMacOSSurfaceMVK( m_instance,
-                                 reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK *>( &createInfo ),
-                                 reinterpret_cast<const VkAllocationCallbacks *>(
-                                   static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
-    return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createMacOSSurfaceMVK" );
-  }
-
-#    ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
-    Instance::createMacOSSurfaceMVKUnique( const MacOSSurfaceCreateInfoMVK &   createInfo,
-                                           Optional<const AllocationCallbacks> allocator,
-                                           Dispatch const &                    d ) const
-  {
-    VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
-    Result                           result = static_cast<Result>(
-      d.vkCreateMacOSSurfaceMVK( m_instance,
-                                 reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK *>( &createInfo ),
-                                 reinterpret_cast<const VkAllocationCallbacks *>(
-                                   static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
-    ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>(
-      result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createMacOSSurfaceMVKUnique", deleter );
-  }
-#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif     /*VK_USE_PLATFORM_MACOS_MVK*/
-
-#if defined( VK_USE_PLATFORM_METAL_EXT )
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Instance::createMetalSurfaceEXT( const VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT * pCreateInfo,
-                                     const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,
-                                     VULKAN_HPP_NAMESPACE::SurfaceKHR *                      pSurface,
-                                     Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkCreateMetalSurfaceEXT( m_instance,
-                                 reinterpret_cast<const VkMetalSurfaceCreateInfoEXT *>( pCreateInfo ),
-                                 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
-                                 reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
-  }
-
-#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
-    Instance::createMetalSurfaceEXT( const MetalSurfaceCreateInfoEXT &   createInfo,
-                                     Optional<const AllocationCallbacks> allocator,
-                                     Dispatch const &                    d ) const
-  {
-    VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
-    Result                           result = static_cast<Result>(
-      d.vkCreateMetalSurfaceEXT( m_instance,
-                                 reinterpret_cast<const VkMetalSurfaceCreateInfoEXT *>( &createInfo ),
-                                 reinterpret_cast<const VkAllocationCallbacks *>(
-                                   static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
-    return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createMetalSurfaceEXT" );
-  }
-
-#    ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
-    Instance::createMetalSurfaceEXTUnique( const MetalSurfaceCreateInfoEXT &   createInfo,
-                                           Optional<const AllocationCallbacks> allocator,
-                                           Dispatch const &                    d ) const
-  {
-    VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
-    Result                           result = static_cast<Result>(
-      d.vkCreateMetalSurfaceEXT( m_instance,
-                                 reinterpret_cast<const VkMetalSurfaceCreateInfoEXT *>( &createInfo ),
-                                 reinterpret_cast<const VkAllocationCallbacks *>(
-                                   static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
-    ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>(
-      result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createMetalSurfaceEXTUnique", deleter );
-  }
-#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif     /*VK_USE_PLATFORM_METAL_EXT*/
-
 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
+  //=== VK_QNX_screen_surface ===
+
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
     Instance::createScreenSurfaceQNX( const VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX * pCreateInfo,
@@ -114921,3258 +119963,7 @@ namespace VULKAN_HPP_NAMESPACE
   }
 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif     /*VK_USE_PLATFORM_SCREEN_QNX*/
 
-#if defined( VK_USE_PLATFORM_GGP )
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createStreamDescriptorSurfaceGGP(
-    const VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP * pCreateInfo,
-    const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                  pAllocator,
-    VULKAN_HPP_NAMESPACE::SurfaceKHR *                                 pSurface,
-    Dispatch const &                                                   d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkCreateStreamDescriptorSurfaceGGP(
-      m_instance,
-      reinterpret_cast<const VkStreamDescriptorSurfaceCreateInfoGGP *>( pCreateInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
-      reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
-  }
-
-#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
-    Instance::createStreamDescriptorSurfaceGGP( const StreamDescriptorSurfaceCreateInfoGGP & createInfo,
-                                                Optional<const AllocationCallbacks>          allocator,
-                                                Dispatch const &                             d ) const
-  {
-    VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
-    Result                           result = static_cast<Result>( d.vkCreateStreamDescriptorSurfaceGGP(
-      m_instance,
-      reinterpret_cast<const VkStreamDescriptorSurfaceCreateInfoGGP *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>(
-        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
-    return createResultValue(
-      result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createStreamDescriptorSurfaceGGP" );
-  }
-
-#    ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
-    Instance::createStreamDescriptorSurfaceGGPUnique( const StreamDescriptorSurfaceCreateInfoGGP & createInfo,
-                                                      Optional<const AllocationCallbacks>          allocator,
-                                                      Dispatch const &                             d ) const
-  {
-    VULKAN_HPP_NAMESPACE::SurfaceKHR  surface;
-    Result                            result = static_cast<Result>( d.vkCreateStreamDescriptorSurfaceGGP(
-      m_instance,
-      reinterpret_cast<const VkStreamDescriptorSurfaceCreateInfoGGP *>( &createInfo ),
-      reinterpret_cast<const VkAllocationCallbacks *>(
-        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
-    ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>(
-      result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createStreamDescriptorSurfaceGGPUnique", deleter );
-  }
-#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif     /*VK_USE_PLATFORM_GGP*/
-
-#if defined( VK_USE_PLATFORM_VI_NN )
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Instance::createViSurfaceNN( const VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN * pCreateInfo,
-                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
-                                 VULKAN_HPP_NAMESPACE::SurfaceKHR *                  pSurface,
-                                 Dispatch const &                                    d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkCreateViSurfaceNN( m_instance,
-                                                       reinterpret_cast<const VkViSurfaceCreateInfoNN *>( pCreateInfo ),
-                                                       reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
-                                                       reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
-  }
-
-#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
-    Instance::createViSurfaceNN( const ViSurfaceCreateInfoNN &       createInfo,
-                                 Optional<const AllocationCallbacks> allocator,
-                                 Dispatch const &                    d ) const
-  {
-    VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
-    Result                           result = static_cast<Result>(
-      d.vkCreateViSurfaceNN( m_instance,
-                             reinterpret_cast<const VkViSurfaceCreateInfoNN *>( &createInfo ),
-                             reinterpret_cast<const VkAllocationCallbacks *>(
-                               static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                             reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
-    return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createViSurfaceNN" );
-  }
-
-#    ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
-    Instance::createViSurfaceNNUnique( const ViSurfaceCreateInfoNN &       createInfo,
-                                       Optional<const AllocationCallbacks> allocator,
-                                       Dispatch const &                    d ) const
-  {
-    VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
-    Result                           result = static_cast<Result>(
-      d.vkCreateViSurfaceNN( m_instance,
-                             reinterpret_cast<const VkViSurfaceCreateInfoNN *>( &createInfo ),
-                             reinterpret_cast<const VkAllocationCallbacks *>(
-                               static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                             reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
-    ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>(
-      result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createViSurfaceNNUnique", deleter );
-  }
-#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif     /*VK_USE_PLATFORM_VI_NN*/
-
-#if defined( VK_USE_PLATFORM_WAYLAND_KHR )
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Instance::createWaylandSurfaceKHR( const VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR * pCreateInfo,
-                                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *         pAllocator,
-                                       VULKAN_HPP_NAMESPACE::SurfaceKHR *                        pSurface,
-                                       Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkCreateWaylandSurfaceKHR( m_instance,
-                                   reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR *>( pCreateInfo ),
-                                   reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
-                                   reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
-  }
-
-#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
-    Instance::createWaylandSurfaceKHR( const WaylandSurfaceCreateInfoKHR & createInfo,
-                                       Optional<const AllocationCallbacks> allocator,
-                                       Dispatch const &                    d ) const
-  {
-    VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
-    Result                           result = static_cast<Result>(
-      d.vkCreateWaylandSurfaceKHR( m_instance,
-                                   reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR *>( &createInfo ),
-                                   reinterpret_cast<const VkAllocationCallbacks *>(
-                                     static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                   reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
-    return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createWaylandSurfaceKHR" );
-  }
-
-#    ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
-    Instance::createWaylandSurfaceKHRUnique( const WaylandSurfaceCreateInfoKHR & createInfo,
-                                             Optional<const AllocationCallbacks> allocator,
-                                             Dispatch const &                    d ) const
-  {
-    VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
-    Result                           result = static_cast<Result>(
-      d.vkCreateWaylandSurfaceKHR( m_instance,
-                                   reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR *>( &createInfo ),
-                                   reinterpret_cast<const VkAllocationCallbacks *>(
-                                     static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                   reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
-    ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>(
-      result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createWaylandSurfaceKHRUnique", deleter );
-  }
-#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif     /*VK_USE_PLATFORM_WAYLAND_KHR*/
-
-#if defined( VK_USE_PLATFORM_WIN32_KHR )
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Instance::createWin32SurfaceKHR( const VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR * pCreateInfo,
-                                     const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,
-                                     VULKAN_HPP_NAMESPACE::SurfaceKHR *                      pSurface,
-                                     Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkCreateWin32SurfaceKHR( m_instance,
-                                 reinterpret_cast<const VkWin32SurfaceCreateInfoKHR *>( pCreateInfo ),
-                                 reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
-                                 reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
-  }
-
-#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
-    Instance::createWin32SurfaceKHR( const Win32SurfaceCreateInfoKHR &   createInfo,
-                                     Optional<const AllocationCallbacks> allocator,
-                                     Dispatch const &                    d ) const
-  {
-    VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
-    Result                           result = static_cast<Result>(
-      d.vkCreateWin32SurfaceKHR( m_instance,
-                                 reinterpret_cast<const VkWin32SurfaceCreateInfoKHR *>( &createInfo ),
-                                 reinterpret_cast<const VkAllocationCallbacks *>(
-                                   static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
-    return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createWin32SurfaceKHR" );
-  }
-
-#    ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
-    Instance::createWin32SurfaceKHRUnique( const Win32SurfaceCreateInfoKHR &   createInfo,
-                                           Optional<const AllocationCallbacks> allocator,
-                                           Dispatch const &                    d ) const
-  {
-    VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
-    Result                           result = static_cast<Result>(
-      d.vkCreateWin32SurfaceKHR( m_instance,
-                                 reinterpret_cast<const VkWin32SurfaceCreateInfoKHR *>( &createInfo ),
-                                 reinterpret_cast<const VkAllocationCallbacks *>(
-                                   static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
-    ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>(
-      result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createWin32SurfaceKHRUnique", deleter );
-  }
-#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif     /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#if defined( VK_USE_PLATFORM_XCB_KHR )
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Instance::createXcbSurfaceKHR( const VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR * pCreateInfo,
-                                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks *     pAllocator,
-                                   VULKAN_HPP_NAMESPACE::SurfaceKHR *                    pSurface,
-                                   Dispatch const &                                      d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkCreateXcbSurfaceKHR( m_instance,
-                               reinterpret_cast<const VkXcbSurfaceCreateInfoKHR *>( pCreateInfo ),
-                               reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
-                               reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
-  }
-
-#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
-    Instance::createXcbSurfaceKHR( const XcbSurfaceCreateInfoKHR &     createInfo,
-                                   Optional<const AllocationCallbacks> allocator,
-                                   Dispatch const &                    d ) const
-  {
-    VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
-    Result                           result = static_cast<Result>(
-      d.vkCreateXcbSurfaceKHR( m_instance,
-                               reinterpret_cast<const VkXcbSurfaceCreateInfoKHR *>( &createInfo ),
-                               reinterpret_cast<const VkAllocationCallbacks *>(
-                                 static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                               reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
-    return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createXcbSurfaceKHR" );
-  }
-
-#    ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
-    Instance::createXcbSurfaceKHRUnique( const XcbSurfaceCreateInfoKHR &     createInfo,
-                                         Optional<const AllocationCallbacks> allocator,
-                                         Dispatch const &                    d ) const
-  {
-    VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
-    Result                           result = static_cast<Result>(
-      d.vkCreateXcbSurfaceKHR( m_instance,
-                               reinterpret_cast<const VkXcbSurfaceCreateInfoKHR *>( &createInfo ),
-                               reinterpret_cast<const VkAllocationCallbacks *>(
-                                 static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                               reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
-    ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>(
-      result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createXcbSurfaceKHRUnique", deleter );
-  }
-#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif     /*VK_USE_PLATFORM_XCB_KHR*/
-
-#if defined( VK_USE_PLATFORM_XLIB_KHR )
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Instance::createXlibSurfaceKHR( const VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR * pCreateInfo,
-                                    const VULKAN_HPP_NAMESPACE::AllocationCallbacks *      pAllocator,
-                                    VULKAN_HPP_NAMESPACE::SurfaceKHR *                     pSurface,
-                                    Dispatch const &                                       d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkCreateXlibSurfaceKHR( m_instance,
-                                reinterpret_cast<const VkXlibSurfaceCreateInfoKHR *>( pCreateInfo ),
-                                reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
-                                reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
-  }
-
-#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
-    Instance::createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR &    createInfo,
-                                    Optional<const AllocationCallbacks> allocator,
-                                    Dispatch const &                    d ) const
-  {
-    VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
-    Result                           result = static_cast<Result>(
-      d.vkCreateXlibSurfaceKHR( m_instance,
-                                reinterpret_cast<const VkXlibSurfaceCreateInfoKHR *>( &createInfo ),
-                                reinterpret_cast<const VkAllocationCallbacks *>(
-                                  static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
-    return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createXlibSurfaceKHR" );
-  }
-
-#    ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
-    Instance::createXlibSurfaceKHRUnique( const XlibSurfaceCreateInfoKHR &    createInfo,
-                                          Optional<const AllocationCallbacks> allocator,
-                                          Dispatch const &                    d ) const
-  {
-    VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
-    Result                           result = static_cast<Result>(
-      d.vkCreateXlibSurfaceKHR( m_instance,
-                                reinterpret_cast<const VkXlibSurfaceCreateInfoKHR *>( &createInfo ),
-                                reinterpret_cast<const VkAllocationCallbacks *>(
-                                  static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
-    ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>(
-      result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createXlibSurfaceKHRUnique", deleter );
-  }
-#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif     /*VK_USE_PLATFORM_XLIB_KHR*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Instance::debugReportMessageEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT      flags,
-                                                          VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType,
-                                                          uint64_t                                       object,
-                                                          size_t                                         location,
-                                                          int32_t                                        messageCode,
-                                                          const char *                                   pLayerPrefix,
-                                                          const char *                                   pMessage,
-                                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDebugReportMessageEXT( m_instance,
-                               static_cast<VkDebugReportFlagsEXT>( flags ),
-                               static_cast<VkDebugReportObjectTypeEXT>( objectType ),
-                               object,
-                               location,
-                               messageCode,
-                               pLayerPrefix,
-                               pMessage );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Instance::debugReportMessageEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT      flags,
-                                                          VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType,
-                                                          uint64_t                                       object,
-                                                          size_t                                         location,
-                                                          int32_t                                        messageCode,
-                                                          const std::string &                            layerPrefix,
-                                                          const std::string &                            message,
-                                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDebugReportMessageEXT( m_instance,
-                               static_cast<VkDebugReportFlagsEXT>( flags ),
-                               static_cast<VkDebugReportObjectTypeEXT>( objectType ),
-                               object,
-                               location,
-                               messageCode,
-                               layerPrefix.c_str(),
-                               message.c_str() );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    Instance::destroyDebugReportCallbackEXT( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT      callback,
-                                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                             Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyDebugReportCallbackEXT( m_instance,
-                                       static_cast<VkDebugReportCallbackEXT>( callback ),
-                                       reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Instance::destroyDebugReportCallbackEXT( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback,
-                                                                  Optional<const AllocationCallbacks> allocator,
-                                                                  Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyDebugReportCallbackEXT(
-      m_instance,
-      static_cast<VkDebugReportCallbackEXT>( callback ),
-      reinterpret_cast<const VkAllocationCallbacks *>(
-        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Instance::destroy( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT      callback,
-                                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                            Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyDebugReportCallbackEXT( m_instance,
-                                       static_cast<VkDebugReportCallbackEXT>( callback ),
-                                       reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Instance::destroy( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback,
-                                            Optional<const AllocationCallbacks>          allocator,
-                                            Dispatch const &                             d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyDebugReportCallbackEXT(
-      m_instance,
-      static_cast<VkDebugReportCallbackEXT>( callback ),
-      reinterpret_cast<const VkAllocationCallbacks *>(
-        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    Instance::destroyDebugUtilsMessengerEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT      messenger,
-                                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                             Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyDebugUtilsMessengerEXT( m_instance,
-                                       static_cast<VkDebugUtilsMessengerEXT>( messenger ),
-                                       reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    Instance::destroyDebugUtilsMessengerEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger,
-                                             Optional<const AllocationCallbacks>          allocator,
-                                             Dispatch const &                             d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyDebugUtilsMessengerEXT(
-      m_instance,
-      static_cast<VkDebugUtilsMessengerEXT>( messenger ),
-      reinterpret_cast<const VkAllocationCallbacks *>(
-        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Instance::destroy( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT      messenger,
-                                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                            Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyDebugUtilsMessengerEXT( m_instance,
-                                       static_cast<VkDebugUtilsMessengerEXT>( messenger ),
-                                       reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Instance::destroy( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger,
-                                            Optional<const AllocationCallbacks>          allocator,
-                                            Dispatch const &                             d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyDebugUtilsMessengerEXT(
-      m_instance,
-      static_cast<VkDebugUtilsMessengerEXT>( messenger ),
-      reinterpret_cast<const VkAllocationCallbacks *>(
-        static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Instance::destroy( const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                            Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyInstance( m_instance, reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Instance::destroy( Optional<const AllocationCallbacks> allocator,
-                                            Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyInstance( m_instance,
-                         reinterpret_cast<const VkAllocationCallbacks *>(
-                           static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Instance::destroySurfaceKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR                  surface,
-                                                      const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                                      Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroySurfaceKHR(
-      m_instance, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Instance::destroySurfaceKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR    surface,
-                                                      Optional<const AllocationCallbacks> allocator,
-                                                      Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroySurfaceKHR( m_instance,
-                           static_cast<VkSurfaceKHR>( surface ),
-                           reinterpret_cast<const VkAllocationCallbacks *>(
-                             static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Instance::destroy( VULKAN_HPP_NAMESPACE::SurfaceKHR                  surface,
-                                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                            Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroySurfaceKHR(
-      m_instance, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Instance::destroy( VULKAN_HPP_NAMESPACE::SurfaceKHR    surface,
-                                            Optional<const AllocationCallbacks> allocator,
-                                            Dispatch const &                    d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroySurfaceKHR( m_instance,
-                           static_cast<VkSurfaceKHR>( surface ),
-                           reinterpret_cast<const VkAllocationCallbacks *>(
-                             static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::enumeratePhysicalDeviceGroups(
-    uint32_t *                                            pPhysicalDeviceGroupCount,
-    VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties,
-    Dispatch const &                                      d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkEnumeratePhysicalDeviceGroups(
-      m_instance,
-      pPhysicalDeviceGroupCount,
-      reinterpret_cast<VkPhysicalDeviceGroupProperties *>( pPhysicalDeviceGroupProperties ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename PhysicalDeviceGroupPropertiesAllocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
-    typename ResultValueType<std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
-    Instance::enumeratePhysicalDeviceGroups( Dispatch const & d ) const
-  {
-    std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator> physicalDeviceGroupProperties;
-    uint32_t                                                                           physicalDeviceGroupCount;
-    Result                                                                             result;
-    do
-    {
-      result =
-        static_cast<Result>( d.vkEnumeratePhysicalDeviceGroups( m_instance, &physicalDeviceGroupCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && physicalDeviceGroupCount )
-      {
-        physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
-        result = static_cast<Result>( d.vkEnumeratePhysicalDeviceGroups(
-          m_instance,
-          &physicalDeviceGroupCount,
-          reinterpret_cast<VkPhysicalDeviceGroupProperties *>( physicalDeviceGroupProperties.data() ) ) );
-        VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( physicalDeviceGroupCount < physicalDeviceGroupProperties.size() ) )
-    {
-      physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
-    }
-    return createResultValue(
-      result, physicalDeviceGroupProperties, VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDeviceGroups" );
-  }
-
-  template <
-    typename PhysicalDeviceGroupPropertiesAllocator,
-    typename Dispatch,
-    typename B,
-    typename std::enable_if<std::is_same<typename B::value_type, PhysicalDeviceGroupProperties>::value, int>::type>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
-    typename ResultValueType<std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
-    Instance::enumeratePhysicalDeviceGroups(
-      PhysicalDeviceGroupPropertiesAllocator & physicalDeviceGroupPropertiesAllocator, Dispatch const & d ) const
-  {
-    std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator> physicalDeviceGroupProperties(
-      physicalDeviceGroupPropertiesAllocator );
-    uint32_t physicalDeviceGroupCount;
-    Result   result;
-    do
-    {
-      result =
-        static_cast<Result>( d.vkEnumeratePhysicalDeviceGroups( m_instance, &physicalDeviceGroupCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && physicalDeviceGroupCount )
-      {
-        physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
-        result = static_cast<Result>( d.vkEnumeratePhysicalDeviceGroups(
-          m_instance,
-          &physicalDeviceGroupCount,
-          reinterpret_cast<VkPhysicalDeviceGroupProperties *>( physicalDeviceGroupProperties.data() ) ) );
-        VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( physicalDeviceGroupCount < physicalDeviceGroupProperties.size() ) )
-    {
-      physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
-    }
-    return createResultValue(
-      result, physicalDeviceGroupProperties, VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDeviceGroups" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::enumeratePhysicalDeviceGroupsKHR(
-    uint32_t *                                            pPhysicalDeviceGroupCount,
-    VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties,
-    Dispatch const &                                      d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkEnumeratePhysicalDeviceGroupsKHR(
-      m_instance,
-      pPhysicalDeviceGroupCount,
-      reinterpret_cast<VkPhysicalDeviceGroupProperties *>( pPhysicalDeviceGroupProperties ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename PhysicalDeviceGroupPropertiesAllocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
-    typename ResultValueType<std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
-    Instance::enumeratePhysicalDeviceGroupsKHR( Dispatch const & d ) const
-  {
-    std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator> physicalDeviceGroupProperties;
-    uint32_t                                                                           physicalDeviceGroupCount;
-    Result                                                                             result;
-    do
-    {
-      result =
-        static_cast<Result>( d.vkEnumeratePhysicalDeviceGroupsKHR( m_instance, &physicalDeviceGroupCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && physicalDeviceGroupCount )
-      {
-        physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
-        result = static_cast<Result>( d.vkEnumeratePhysicalDeviceGroupsKHR(
-          m_instance,
-          &physicalDeviceGroupCount,
-          reinterpret_cast<VkPhysicalDeviceGroupProperties *>( physicalDeviceGroupProperties.data() ) ) );
-        VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( physicalDeviceGroupCount < physicalDeviceGroupProperties.size() ) )
-    {
-      physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
-    }
-    return createResultValue( result,
-                              physicalDeviceGroupProperties,
-                              VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDeviceGroupsKHR" );
-  }
-
-  template <
-    typename PhysicalDeviceGroupPropertiesAllocator,
-    typename Dispatch,
-    typename B,
-    typename std::enable_if<std::is_same<typename B::value_type, PhysicalDeviceGroupProperties>::value, int>::type>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
-    typename ResultValueType<std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
-    Instance::enumeratePhysicalDeviceGroupsKHR(
-      PhysicalDeviceGroupPropertiesAllocator & physicalDeviceGroupPropertiesAllocator, Dispatch const & d ) const
-  {
-    std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator> physicalDeviceGroupProperties(
-      physicalDeviceGroupPropertiesAllocator );
-    uint32_t physicalDeviceGroupCount;
-    Result   result;
-    do
-    {
-      result =
-        static_cast<Result>( d.vkEnumeratePhysicalDeviceGroupsKHR( m_instance, &physicalDeviceGroupCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && physicalDeviceGroupCount )
-      {
-        physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
-        result = static_cast<Result>( d.vkEnumeratePhysicalDeviceGroupsKHR(
-          m_instance,
-          &physicalDeviceGroupCount,
-          reinterpret_cast<VkPhysicalDeviceGroupProperties *>( physicalDeviceGroupProperties.data() ) ) );
-        VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( physicalDeviceGroupCount < physicalDeviceGroupProperties.size() ) )
-    {
-      physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
-    }
-    return createResultValue( result,
-                              physicalDeviceGroupProperties,
-                              VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDeviceGroupsKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Instance::enumeratePhysicalDevices( uint32_t *                             pPhysicalDeviceCount,
-                                        VULKAN_HPP_NAMESPACE::PhysicalDevice * pPhysicalDevices,
-                                        Dispatch const &                       d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkEnumeratePhysicalDevices(
-      m_instance, pPhysicalDeviceCount, reinterpret_cast<VkPhysicalDevice *>( pPhysicalDevices ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename PhysicalDeviceAllocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
-    typename ResultValueType<std::vector<PhysicalDevice, PhysicalDeviceAllocator>>::type
-    Instance::enumeratePhysicalDevices( Dispatch const & d ) const
-  {
-    std::vector<PhysicalDevice, PhysicalDeviceAllocator> physicalDevices;
-    uint32_t                                             physicalDeviceCount;
-    Result                                               result;
-    do
-    {
-      result = static_cast<Result>( d.vkEnumeratePhysicalDevices( m_instance, &physicalDeviceCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && physicalDeviceCount )
-      {
-        physicalDevices.resize( physicalDeviceCount );
-        result = static_cast<Result>( d.vkEnumeratePhysicalDevices(
-          m_instance, &physicalDeviceCount, reinterpret_cast<VkPhysicalDevice *>( physicalDevices.data() ) ) );
-        VULKAN_HPP_ASSERT( physicalDeviceCount <= physicalDevices.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( physicalDeviceCount < physicalDevices.size() ) )
-    {
-      physicalDevices.resize( physicalDeviceCount );
-    }
-    return createResultValue(
-      result, physicalDevices, VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDevices" );
-  }
-
-  template <typename PhysicalDeviceAllocator,
-            typename Dispatch,
-            typename B,
-            typename std::enable_if<std::is_same<typename B::value_type, PhysicalDevice>::value, int>::type>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
-    typename ResultValueType<std::vector<PhysicalDevice, PhysicalDeviceAllocator>>::type
-    Instance::enumeratePhysicalDevices( PhysicalDeviceAllocator & physicalDeviceAllocator, Dispatch const & d ) const
-  {
-    std::vector<PhysicalDevice, PhysicalDeviceAllocator> physicalDevices( physicalDeviceAllocator );
-    uint32_t                                             physicalDeviceCount;
-    Result                                               result;
-    do
-    {
-      result = static_cast<Result>( d.vkEnumeratePhysicalDevices( m_instance, &physicalDeviceCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && physicalDeviceCount )
-      {
-        physicalDevices.resize( physicalDeviceCount );
-        result = static_cast<Result>( d.vkEnumeratePhysicalDevices(
-          m_instance, &physicalDeviceCount, reinterpret_cast<VkPhysicalDevice *>( physicalDevices.data() ) ) );
-        VULKAN_HPP_ASSERT( physicalDeviceCount <= physicalDevices.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( physicalDeviceCount < physicalDevices.size() ) )
-    {
-      physicalDevices.resize( physicalDeviceCount );
-    }
-    return createResultValue(
-      result, physicalDevices, VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDevices" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE PFN_vkVoidFunction Instance::getProcAddr( const char *     pName,
-                                                              Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return d.vkGetInstanceProcAddr( m_instance, pName );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE PFN_vkVoidFunction Instance::getProcAddr( const std::string & name,
-                                                              Dispatch const &    d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return d.vkGetInstanceProcAddr( m_instance, name.c_str() );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Instance::submitDebugUtilsMessageEXT(
-    VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagBitsEXT       messageSeverity,
-    VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT              messageTypes,
-    const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT * pCallbackData,
-    Dispatch const &                                                 d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkSubmitDebugUtilsMessageEXT( m_instance,
-                                    static_cast<VkDebugUtilsMessageSeverityFlagBitsEXT>( messageSeverity ),
-                                    static_cast<VkDebugUtilsMessageTypeFlagsEXT>( messageTypes ),
-                                    reinterpret_cast<const VkDebugUtilsMessengerCallbackDataEXT *>( pCallbackData ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    Instance::submitDebugUtilsMessageEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
-                                          VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT        messageTypes,
-                                          const DebugUtilsMessengerCallbackDataEXT &                 callbackData,
-                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkSubmitDebugUtilsMessageEXT( m_instance,
-                                    static_cast<VkDebugUtilsMessageSeverityFlagBitsEXT>( messageSeverity ),
-                                    static_cast<VkDebugUtilsMessageTypeFlagsEXT>( messageTypes ),
-                                    reinterpret_cast<const VkDebugUtilsMessengerCallbackDataEXT *>( &callbackData ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#if defined( VK_USE_PLATFORM_WIN32_KHR )
-#  ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::acquireWinrtDisplayNV(
-    VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkAcquireWinrtDisplayNV( m_physicalDevice, static_cast<VkDisplayKHR>( display ) ) );
-  }
-#  else
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
-    PhysicalDevice::acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d ) const
-  {
-    Result result =
-      static_cast<Result>( d.vkAcquireWinrtDisplayNV( m_physicalDevice, static_cast<VkDisplayKHR>( display ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::acquireWinrtDisplayNV" );
-  }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::acquireXlibDisplayEXT(
-    Display * dpy, VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkAcquireXlibDisplayEXT( m_physicalDevice, dpy, static_cast<VkDisplayKHR>( display ) ) );
-  }
-
-#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
-                                          PhysicalDevice::acquireXlibDisplayEXT( Display &                        dpy,
-                                           VULKAN_HPP_NAMESPACE::DisplayKHR display,
-                                           Dispatch const &                 d ) const
-  {
-    Result result =
-      static_cast<Result>( d.vkAcquireXlibDisplayEXT( m_physicalDevice, &dpy, static_cast<VkDisplayKHR>( display ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::acquireXlibDisplayEXT" );
-  }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    PhysicalDevice::createDevice( const VULKAN_HPP_NAMESPACE::DeviceCreateInfo *    pCreateInfo,
-                                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                  VULKAN_HPP_NAMESPACE::Device *                    pDevice,
-                                  Dispatch const &                                  d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkCreateDevice( m_physicalDevice,
-                                                  reinterpret_cast<const VkDeviceCreateInfo *>( pCreateInfo ),
-                                                  reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
-                                                  reinterpret_cast<VkDevice *>( pDevice ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::Device>::type
-                                          PhysicalDevice::createDevice( const DeviceCreateInfo &            createInfo,
-                                  Optional<const AllocationCallbacks> allocator,
-                                  Dispatch const &                    d ) const
-  {
-    VULKAN_HPP_NAMESPACE::Device device;
-    Result                       result = static_cast<Result>(
-      d.vkCreateDevice( m_physicalDevice,
-                        reinterpret_cast<const VkDeviceCreateInfo *>( &createInfo ),
-                        reinterpret_cast<const VkAllocationCallbacks *>(
-                          static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                        reinterpret_cast<VkDevice *>( &device ) ) );
-    return createResultValue( result, device, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::createDevice" );
-  }
-
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Device, Dispatch>>::type
-    PhysicalDevice::createDeviceUnique( const DeviceCreateInfo &            createInfo,
-                                        Optional<const AllocationCallbacks> allocator,
-                                        Dispatch const &                    d ) const
-  {
-    VULKAN_HPP_NAMESPACE::Device device;
-    Result                       result = static_cast<Result>(
-      d.vkCreateDevice( m_physicalDevice,
-                        reinterpret_cast<const VkDeviceCreateInfo *>( &createInfo ),
-                        reinterpret_cast<const VkAllocationCallbacks *>(
-                          static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                        reinterpret_cast<VkDevice *>( &device ) ) );
-    ObjectDestroy<NoParent, Dispatch> deleter( allocator, d );
-    return createResultValue<VULKAN_HPP_NAMESPACE::Device, Dispatch>(
-      result, device, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::createDeviceUnique", deleter );
-  }
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    PhysicalDevice::createDisplayModeKHR( VULKAN_HPP_NAMESPACE::DisplayKHR                       display,
-                                          const VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR * pCreateInfo,
-                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks *      pAllocator,
-                                          VULKAN_HPP_NAMESPACE::DisplayModeKHR *                 pMode,
-                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkCreateDisplayModeKHR( m_physicalDevice,
-                                static_cast<VkDisplayKHR>( display ),
-                                reinterpret_cast<const VkDisplayModeCreateInfoKHR *>( pCreateInfo ),
-                                reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
-                                reinterpret_cast<VkDisplayModeKHR *>( pMode ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayModeKHR>::type
-    PhysicalDevice::createDisplayModeKHR( VULKAN_HPP_NAMESPACE::DisplayKHR    display,
-                                          const DisplayModeCreateInfoKHR &    createInfo,
-                                          Optional<const AllocationCallbacks> allocator,
-                                          Dispatch const &                    d ) const
-  {
-    VULKAN_HPP_NAMESPACE::DisplayModeKHR mode;
-    Result                               result = static_cast<Result>(
-      d.vkCreateDisplayModeKHR( m_physicalDevice,
-                                static_cast<VkDisplayKHR>( display ),
-                                reinterpret_cast<const VkDisplayModeCreateInfoKHR *>( &createInfo ),
-                                reinterpret_cast<const VkAllocationCallbacks *>(
-                                  static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                reinterpret_cast<VkDisplayModeKHR *>( &mode ) ) );
-    return createResultValue( result, mode, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::createDisplayModeKHR" );
-  }
-
-#  ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayModeKHR, Dispatch>>::type
-    PhysicalDevice::createDisplayModeKHRUnique( VULKAN_HPP_NAMESPACE::DisplayKHR    display,
-                                                const DisplayModeCreateInfoKHR &    createInfo,
-                                                Optional<const AllocationCallbacks> allocator,
-                                                Dispatch const &                    d ) const
-  {
-    VULKAN_HPP_NAMESPACE::DisplayModeKHR mode;
-    Result                               result = static_cast<Result>(
-      d.vkCreateDisplayModeKHR( m_physicalDevice,
-                                static_cast<VkDisplayKHR>( display ),
-                                reinterpret_cast<const VkDisplayModeCreateInfoKHR *>( &createInfo ),
-                                reinterpret_cast<const VkAllocationCallbacks *>(
-                                  static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-                                reinterpret_cast<VkDisplayModeKHR *>( &mode ) ) );
-    ObjectDestroy<PhysicalDevice, Dispatch> deleter( *this, allocator, d );
-    return createResultValue<VULKAN_HPP_NAMESPACE::DisplayModeKHR, Dispatch>(
-      result, mode, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::createDisplayModeKHRUnique", deleter );
-  }
-#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    PhysicalDevice::enumerateDeviceExtensionProperties( const char *                                pLayerName,
-                                                        uint32_t *                                  pPropertyCount,
-                                                        VULKAN_HPP_NAMESPACE::ExtensionProperties * pProperties,
-                                                        Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkEnumerateDeviceExtensionProperties(
-      m_physicalDevice, pLayerName, pPropertyCount, reinterpret_cast<VkExtensionProperties *>( pProperties ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename ExtensionPropertiesAllocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
-    typename ResultValueType<std::vector<ExtensionProperties, ExtensionPropertiesAllocator>>::type
-    PhysicalDevice::enumerateDeviceExtensionProperties( Optional<const std::string> layerName,
-                                                        Dispatch const &            d ) const
-  {
-    std::vector<ExtensionProperties, ExtensionPropertiesAllocator> properties;
-    uint32_t                                                       propertyCount;
-    Result                                                         result;
-    do
-    {
-      result = static_cast<Result>( d.vkEnumerateDeviceExtensionProperties(
-        m_physicalDevice, layerName ? layerName->c_str() : nullptr, &propertyCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && propertyCount )
-      {
-        properties.resize( propertyCount );
-        result = static_cast<Result>(
-          d.vkEnumerateDeviceExtensionProperties( m_physicalDevice,
-                                                  layerName ? layerName->c_str() : nullptr,
-                                                  &propertyCount,
-                                                  reinterpret_cast<VkExtensionProperties *>( properties.data() ) ) );
-        VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) )
-    {
-      properties.resize( propertyCount );
-    }
-    return createResultValue(
-      result, properties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateDeviceExtensionProperties" );
-  }
-
-  template <typename ExtensionPropertiesAllocator,
-            typename Dispatch,
-            typename B,
-            typename std::enable_if<std::is_same<typename B::value_type, ExtensionProperties>::value, int>::type>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
-    typename ResultValueType<std::vector<ExtensionProperties, ExtensionPropertiesAllocator>>::type
-    PhysicalDevice::enumerateDeviceExtensionProperties( Optional<const std::string>    layerName,
-                                                        ExtensionPropertiesAllocator & extensionPropertiesAllocator,
-                                                        Dispatch const &               d ) const
-  {
-    std::vector<ExtensionProperties, ExtensionPropertiesAllocator> properties( extensionPropertiesAllocator );
-    uint32_t                                                       propertyCount;
-    Result                                                         result;
-    do
-    {
-      result = static_cast<Result>( d.vkEnumerateDeviceExtensionProperties(
-        m_physicalDevice, layerName ? layerName->c_str() : nullptr, &propertyCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && propertyCount )
-      {
-        properties.resize( propertyCount );
-        result = static_cast<Result>(
-          d.vkEnumerateDeviceExtensionProperties( m_physicalDevice,
-                                                  layerName ? layerName->c_str() : nullptr,
-                                                  &propertyCount,
-                                                  reinterpret_cast<VkExtensionProperties *>( properties.data() ) ) );
-        VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) )
-    {
-      properties.resize( propertyCount );
-    }
-    return createResultValue(
-      result, properties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateDeviceExtensionProperties" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    PhysicalDevice::enumerateDeviceLayerProperties( uint32_t *                              pPropertyCount,
-                                                    VULKAN_HPP_NAMESPACE::LayerProperties * pProperties,
-                                                    Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkEnumerateDeviceLayerProperties(
-      m_physicalDevice, pPropertyCount, reinterpret_cast<VkLayerProperties *>( pProperties ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename LayerPropertiesAllocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
-    typename ResultValueType<std::vector<LayerProperties, LayerPropertiesAllocator>>::type
-    PhysicalDevice::enumerateDeviceLayerProperties( Dispatch const & d ) const
-  {
-    std::vector<LayerProperties, LayerPropertiesAllocator> properties;
-    uint32_t                                               propertyCount;
-    Result                                                 result;
-    do
-    {
-      result = static_cast<Result>( d.vkEnumerateDeviceLayerProperties( m_physicalDevice, &propertyCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && propertyCount )
-      {
-        properties.resize( propertyCount );
-        result = static_cast<Result>( d.vkEnumerateDeviceLayerProperties(
-          m_physicalDevice, &propertyCount, reinterpret_cast<VkLayerProperties *>( properties.data() ) ) );
-        VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) )
-    {
-      properties.resize( propertyCount );
-    }
-    return createResultValue(
-      result, properties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateDeviceLayerProperties" );
-  }
-
-  template <typename LayerPropertiesAllocator,
-            typename Dispatch,
-            typename B,
-            typename std::enable_if<std::is_same<typename B::value_type, LayerProperties>::value, int>::type>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
-    typename ResultValueType<std::vector<LayerProperties, LayerPropertiesAllocator>>::type
-    PhysicalDevice::enumerateDeviceLayerProperties( LayerPropertiesAllocator & layerPropertiesAllocator,
-                                                    Dispatch const &           d ) const
-  {
-    std::vector<LayerProperties, LayerPropertiesAllocator> properties( layerPropertiesAllocator );
-    uint32_t                                               propertyCount;
-    Result                                                 result;
-    do
-    {
-      result = static_cast<Result>( d.vkEnumerateDeviceLayerProperties( m_physicalDevice, &propertyCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && propertyCount )
-      {
-        properties.resize( propertyCount );
-        result = static_cast<Result>( d.vkEnumerateDeviceLayerProperties(
-          m_physicalDevice, &propertyCount, reinterpret_cast<VkLayerProperties *>( properties.data() ) ) );
-        VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) )
-    {
-      properties.resize( propertyCount );
-    }
-    return createResultValue(
-      result, properties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateDeviceLayerProperties" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR(
-    uint32_t                                                 queueFamilyIndex,
-    uint32_t *                                               pCounterCount,
-    VULKAN_HPP_NAMESPACE::PerformanceCounterKHR *            pCounters,
-    VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR * pCounterDescriptions,
-    Dispatch const &                                         d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
-      m_physicalDevice,
-      queueFamilyIndex,
-      pCounterCount,
-      reinterpret_cast<VkPerformanceCounterKHR *>( pCounters ),
-      reinterpret_cast<VkPerformanceCounterDescriptionKHR *>( pCounterDescriptions ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator, typename Dispatch>
-  VULKAN_HPP_DEPRECATED( "This function is deprecated. Use one of the other flavours of it." )
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
-    typename ResultValueType<std::vector<PerformanceCounterDescriptionKHR, Allocator>>::type
-    PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR(
-      uint32_t                                                        queueFamilyIndex,
-      ArrayProxy<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR> const & counters,
-      Dispatch const &                                                d ) const
-  {
-    std::vector<PerformanceCounterDescriptionKHR, Allocator> counterDescriptions;
-    uint32_t                                                 counterCount;
-    Result                                                   result;
-    do
-    {
-      result = static_cast<Result>( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
-        m_physicalDevice,
-        queueFamilyIndex,
-        counters.size(),
-        reinterpret_cast<VkPerformanceCounterKHR *>( counters.data() ),
-        nullptr ) );
-      if ( ( result == Result::eSuccess ) && counterCount )
-      {
-        counterDescriptions.resize( counterCount );
-        result = static_cast<Result>( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
-          m_physicalDevice,
-          queueFamilyIndex,
-          counters.size(),
-          reinterpret_cast<VkPerformanceCounterKHR *>( counters.data() ),
-          reinterpret_cast<VkPerformanceCounterDescriptionKHR *>( counterDescriptions.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( result == Result::eSuccess )
-    {
-      VULKAN_HPP_ASSERT( counterCount <= counterDescriptions.size() );
-      counterDescriptions.resize( counterCount );
-    }
-    return createResultValue( result,
-                              counterDescriptions,
-                              VULKAN_HPP_NAMESPACE_STRING
-                              "::PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR" );
-  }
-
-  template <
-    typename Allocator,
-    typename Dispatch,
-    typename B,
-    typename std::enable_if<std::is_same<typename B::value_type, PerformanceCounterDescriptionKHR>::value, int>::type>
-  VULKAN_HPP_DEPRECATED( "This function is deprecated. Use one of the other flavours of it." )
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
-    typename ResultValueType<std::vector<PerformanceCounterDescriptionKHR, Allocator>>::type
-    PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR(
-      uint32_t                                                        queueFamilyIndex,
-      ArrayProxy<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR> const & counters,
-      Allocator const &                                               vectorAllocator,
-      Dispatch const &                                                d ) const
-  {
-    std::vector<PerformanceCounterDescriptionKHR, Allocator> counterDescriptions( vectorAllocator );
-    uint32_t                                                 counterCount;
-    Result                                                   result;
-    do
-    {
-      result = static_cast<Result>( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
-        m_physicalDevice,
-        queueFamilyIndex,
-        counters.size(),
-        reinterpret_cast<VkPerformanceCounterKHR *>( counters.data() ),
-        nullptr ) );
-      if ( ( result == Result::eSuccess ) && counterCount )
-      {
-        counterDescriptions.resize( counterCount );
-        result = static_cast<Result>( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
-          m_physicalDevice,
-          queueFamilyIndex,
-          counters.size(),
-          reinterpret_cast<VkPerformanceCounterKHR *>( counters.data() ),
-          reinterpret_cast<VkPerformanceCounterDescriptionKHR *>( counterDescriptions.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( result == Result::eSuccess )
-    {
-      VULKAN_HPP_ASSERT( counterCount <= counterDescriptions.size() );
-      counterDescriptions.resize( counterCount );
-    }
-    return createResultValue( result,
-                              counterDescriptions,
-                              VULKAN_HPP_NAMESPACE_STRING
-                              "::PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR" );
-  }
-
-  template <typename PerformanceCounterKHRAllocator,
-            typename PerformanceCounterDescriptionKHRAllocator,
-            typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<
-    std::pair<std::vector<PerformanceCounterKHR, PerformanceCounterKHRAllocator>,
-              std::vector<PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>>>::type
-    PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t         queueFamilyIndex,
-                                                                     Dispatch const & d ) const
-  {
-    std::pair<std::vector<PerformanceCounterKHR, PerformanceCounterKHRAllocator>,
-              std::vector<PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>>
-                                                                                               data;
-    std::vector<PerformanceCounterKHR, PerformanceCounterKHRAllocator> &                       counters = data.first;
-    std::vector<PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator> & counterDescriptions =
-      data.second;
-    uint32_t counterCount;
-    Result   result;
-    do
-    {
-      result = static_cast<Result>( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
-        m_physicalDevice, queueFamilyIndex, &counterCount, nullptr, nullptr ) );
-      if ( ( result == Result::eSuccess ) && counterCount )
-      {
-        counters.resize( counterCount );
-        counterDescriptions.resize( counterCount );
-        result = static_cast<Result>( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
-          m_physicalDevice,
-          queueFamilyIndex,
-          &counterCount,
-          reinterpret_cast<VkPerformanceCounterKHR *>( counters.data() ),
-          reinterpret_cast<VkPerformanceCounterDescriptionKHR *>( counterDescriptions.data() ) ) );
-        VULKAN_HPP_ASSERT( counterCount <= counters.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( counterCount < counters.size() ) )
-    {
-      counters.resize( counterCount );
-      counterDescriptions.resize( counterCount );
-    }
-    return createResultValue(
-      result, data, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR" );
-  }
-
-  template <typename PerformanceCounterKHRAllocator,
-            typename PerformanceCounterDescriptionKHRAllocator,
-            typename Dispatch,
-            typename B1,
-            typename B2,
-            typename std::enable_if<std::is_same<typename B1::value_type, PerformanceCounterKHR>::value &&
-                                      std::is_same<typename B2::value_type, PerformanceCounterDescriptionKHR>::value,
-                                    int>::type>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<
-    std::pair<std::vector<PerformanceCounterKHR, PerformanceCounterKHRAllocator>,
-              std::vector<PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>>>::type
-    PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR(
-      uint32_t                                    queueFamilyIndex,
-      PerformanceCounterKHRAllocator &            performanceCounterKHRAllocator,
-      PerformanceCounterDescriptionKHRAllocator & performanceCounterDescriptionKHRAllocator,
-      Dispatch const &                            d ) const
-  {
-    std::pair<std::vector<PerformanceCounterKHR, PerformanceCounterKHRAllocator>,
-              std::vector<PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>>
-                                                                         data( std::piecewise_construct,
-            std::forward_as_tuple( performanceCounterKHRAllocator ),
-            std::forward_as_tuple( performanceCounterDescriptionKHRAllocator ) );
-    std::vector<PerformanceCounterKHR, PerformanceCounterKHRAllocator> & counters = data.first;
-    std::vector<PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator> & counterDescriptions =
-      data.second;
-    uint32_t counterCount;
-    Result   result;
-    do
-    {
-      result = static_cast<Result>( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
-        m_physicalDevice, queueFamilyIndex, &counterCount, nullptr, nullptr ) );
-      if ( ( result == Result::eSuccess ) && counterCount )
-      {
-        counters.resize( counterCount );
-        counterDescriptions.resize( counterCount );
-        result = static_cast<Result>( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
-          m_physicalDevice,
-          queueFamilyIndex,
-          &counterCount,
-          reinterpret_cast<VkPerformanceCounterKHR *>( counters.data() ),
-          reinterpret_cast<VkPerformanceCounterDescriptionKHR *>( counterDescriptions.data() ) ) );
-        VULKAN_HPP_ASSERT( counterCount <= counters.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( counterCount < counters.size() ) )
-    {
-      counters.resize( counterCount );
-      counterDescriptions.resize( counterCount );
-    }
-    return createResultValue(
-      result, data, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    PhysicalDevice::getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR                  display,
-                                                  uint32_t *                                        pPropertyCount,
-                                                  VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR * pProperties,
-                                                  Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkGetDisplayModeProperties2KHR( m_physicalDevice,
-                                        static_cast<VkDisplayKHR>( display ),
-                                        pPropertyCount,
-                                        reinterpret_cast<VkDisplayModeProperties2KHR *>( pProperties ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename DisplayModeProperties2KHRAllocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
-    typename ResultValueType<std::vector<DisplayModeProperties2KHR, DisplayModeProperties2KHRAllocator>>::type
-    PhysicalDevice::getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d ) const
-  {
-    std::vector<DisplayModeProperties2KHR, DisplayModeProperties2KHRAllocator> properties;
-    uint32_t                                                                   propertyCount;
-    Result                                                                     result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetDisplayModeProperties2KHR(
-        m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && propertyCount )
-      {
-        properties.resize( propertyCount );
-        result = static_cast<Result>(
-          d.vkGetDisplayModeProperties2KHR( m_physicalDevice,
-                                            static_cast<VkDisplayKHR>( display ),
-                                            &propertyCount,
-                                            reinterpret_cast<VkDisplayModeProperties2KHR *>( properties.data() ) ) );
-        VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) )
-    {
-      properties.resize( propertyCount );
-    }
-    return createResultValue(
-      result, properties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayModeProperties2KHR" );
-  }
-
-  template <typename DisplayModeProperties2KHRAllocator,
-            typename Dispatch,
-            typename B,
-            typename std::enable_if<std::is_same<typename B::value_type, DisplayModeProperties2KHR>::value, int>::type>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
-    typename ResultValueType<std::vector<DisplayModeProperties2KHR, DisplayModeProperties2KHRAllocator>>::type
-    PhysicalDevice::getDisplayModeProperties2KHR(
-      VULKAN_HPP_NAMESPACE::DisplayKHR     display,
-      DisplayModeProperties2KHRAllocator & displayModeProperties2KHRAllocator,
-      Dispatch const &                     d ) const
-  {
-    std::vector<DisplayModeProperties2KHR, DisplayModeProperties2KHRAllocator> properties(
-      displayModeProperties2KHRAllocator );
-    uint32_t propertyCount;
-    Result   result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetDisplayModeProperties2KHR(
-        m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && propertyCount )
-      {
-        properties.resize( propertyCount );
-        result = static_cast<Result>(
-          d.vkGetDisplayModeProperties2KHR( m_physicalDevice,
-                                            static_cast<VkDisplayKHR>( display ),
-                                            &propertyCount,
-                                            reinterpret_cast<VkDisplayModeProperties2KHR *>( properties.data() ) ) );
-        VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) )
-    {
-      properties.resize( propertyCount );
-    }
-    return createResultValue(
-      result, properties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayModeProperties2KHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    PhysicalDevice::getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR                 display,
-                                                 uint32_t *                                       pPropertyCount,
-                                                 VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR * pProperties,
-                                                 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkGetDisplayModePropertiesKHR( m_physicalDevice,
-                                       static_cast<VkDisplayKHR>( display ),
-                                       pPropertyCount,
-                                       reinterpret_cast<VkDisplayModePropertiesKHR *>( pProperties ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename DisplayModePropertiesKHRAllocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
-    typename ResultValueType<std::vector<DisplayModePropertiesKHR, DisplayModePropertiesKHRAllocator>>::type
-    PhysicalDevice::getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d ) const
-  {
-    std::vector<DisplayModePropertiesKHR, DisplayModePropertiesKHRAllocator> properties;
-    uint32_t                                                                 propertyCount;
-    Result                                                                   result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetDisplayModePropertiesKHR(
-        m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && propertyCount )
-      {
-        properties.resize( propertyCount );
-        result = static_cast<Result>(
-          d.vkGetDisplayModePropertiesKHR( m_physicalDevice,
-                                           static_cast<VkDisplayKHR>( display ),
-                                           &propertyCount,
-                                           reinterpret_cast<VkDisplayModePropertiesKHR *>( properties.data() ) ) );
-        VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) )
-    {
-      properties.resize( propertyCount );
-    }
-    return createResultValue(
-      result, properties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayModePropertiesKHR" );
-  }
-
-  template <typename DisplayModePropertiesKHRAllocator,
-            typename Dispatch,
-            typename B,
-            typename std::enable_if<std::is_same<typename B::value_type, DisplayModePropertiesKHR>::value, int>::type>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
-    typename ResultValueType<std::vector<DisplayModePropertiesKHR, DisplayModePropertiesKHRAllocator>>::type
-    PhysicalDevice::getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR    display,
-                                                 DisplayModePropertiesKHRAllocator & displayModePropertiesKHRAllocator,
-                                                 Dispatch const &                    d ) const
-  {
-    std::vector<DisplayModePropertiesKHR, DisplayModePropertiesKHRAllocator> properties(
-      displayModePropertiesKHRAllocator );
-    uint32_t propertyCount;
-    Result   result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetDisplayModePropertiesKHR(
-        m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && propertyCount )
-      {
-        properties.resize( propertyCount );
-        result = static_cast<Result>(
-          d.vkGetDisplayModePropertiesKHR( m_physicalDevice,
-                                           static_cast<VkDisplayKHR>( display ),
-                                           &propertyCount,
-                                           reinterpret_cast<VkDisplayModePropertiesKHR *>( properties.data() ) ) );
-        VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) )
-    {
-      properties.resize( propertyCount );
-    }
-    return createResultValue(
-      result, properties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayModePropertiesKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlaneCapabilities2KHR(
-    const VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR *   pDisplayPlaneInfo,
-    VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR * pCapabilities,
-    Dispatch const &                                     d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkGetDisplayPlaneCapabilities2KHR( m_physicalDevice,
-                                           reinterpret_cast<const VkDisplayPlaneInfo2KHR *>( pDisplayPlaneInfo ),
-                                           reinterpret_cast<VkDisplayPlaneCapabilities2KHR *>( pCapabilities ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR>::type
-    PhysicalDevice::getDisplayPlaneCapabilities2KHR( const DisplayPlaneInfo2KHR & displayPlaneInfo,
-                                                     Dispatch const &             d ) const
-  {
-    VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR capabilities;
-    Result                                             result = static_cast<Result>(
-      d.vkGetDisplayPlaneCapabilities2KHR( m_physicalDevice,
-                                           reinterpret_cast<const VkDisplayPlaneInfo2KHR *>( &displayPlaneInfo ),
-                                           reinterpret_cast<VkDisplayPlaneCapabilities2KHR *>( &capabilities ) ) );
-    return createResultValue(
-      result, capabilities, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneCapabilities2KHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    PhysicalDevice::getDisplayPlaneCapabilitiesKHR( VULKAN_HPP_NAMESPACE::DisplayModeKHR                mode,
-                                                    uint32_t                                            planeIndex,
-                                                    VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR * pCapabilities,
-                                                    Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkGetDisplayPlaneCapabilitiesKHR( m_physicalDevice,
-                                          static_cast<VkDisplayModeKHR>( mode ),
-                                          planeIndex,
-                                          reinterpret_cast<VkDisplayPlaneCapabilitiesKHR *>( pCapabilities ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR>::type
-    PhysicalDevice::getDisplayPlaneCapabilitiesKHR( VULKAN_HPP_NAMESPACE::DisplayModeKHR mode,
-                                                    uint32_t                             planeIndex,
-                                                    Dispatch const &                     d ) const
-  {
-    VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR capabilities;
-    Result                                            result = static_cast<Result>(
-      d.vkGetDisplayPlaneCapabilitiesKHR( m_physicalDevice,
-                                          static_cast<VkDisplayModeKHR>( mode ),
-                                          planeIndex,
-                                          reinterpret_cast<VkDisplayPlaneCapabilitiesKHR *>( &capabilities ) ) );
-    return createResultValue(
-      result, capabilities, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneCapabilitiesKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR( uint32_t                           planeIndex,
-                                                         uint32_t *                         pDisplayCount,
-                                                         VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplays,
-                                                         Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkGetDisplayPlaneSupportedDisplaysKHR(
-      m_physicalDevice, planeIndex, pDisplayCount, reinterpret_cast<VkDisplayKHR *>( pDisplays ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename DisplayKHRAllocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayKHR, DisplayKHRAllocator>>::type
-    PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, Dispatch const & d ) const
-  {
-    std::vector<DisplayKHR, DisplayKHRAllocator> displays;
-    uint32_t                                     displayCount;
-    Result                                       result;
-    do
-    {
-      result = static_cast<Result>(
-        d.vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, &displayCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && displayCount )
-      {
-        displays.resize( displayCount );
-        result = static_cast<Result>( d.vkGetDisplayPlaneSupportedDisplaysKHR(
-          m_physicalDevice, planeIndex, &displayCount, reinterpret_cast<VkDisplayKHR *>( displays.data() ) ) );
-        VULKAN_HPP_ASSERT( displayCount <= displays.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( displayCount < displays.size() ) )
-    {
-      displays.resize( displayCount );
-    }
-    return createResultValue(
-      result, displays, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR" );
-  }
-
-  template <typename DisplayKHRAllocator,
-            typename Dispatch,
-            typename B,
-            typename std::enable_if<std::is_same<typename B::value_type, DisplayKHR>::value, int>::type>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayKHR, DisplayKHRAllocator>>::type
-                       PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR( uint32_t              planeIndex,
-                                                         DisplayKHRAllocator & displayKHRAllocator,
-                                                         Dispatch const &      d ) const
-  {
-    std::vector<DisplayKHR, DisplayKHRAllocator> displays( displayKHRAllocator );
-    uint32_t                                     displayCount;
-    Result                                       result;
-    do
-    {
-      result = static_cast<Result>(
-        d.vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, &displayCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && displayCount )
-      {
-        displays.resize( displayCount );
-        result = static_cast<Result>( d.vkGetDisplayPlaneSupportedDisplaysKHR(
-          m_physicalDevice, planeIndex, &displayCount, reinterpret_cast<VkDisplayKHR *>( displays.data() ) ) );
-        VULKAN_HPP_ASSERT( displayCount <= displays.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( displayCount < displays.size() ) )
-    {
-      displays.resize( displayCount );
-    }
-    return createResultValue(
-      result, displays, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    PhysicalDevice::getCalibrateableTimeDomainsEXT( uint32_t *                            pTimeDomainCount,
-                                                    VULKAN_HPP_NAMESPACE::TimeDomainEXT * pTimeDomains,
-                                                    Dispatch const &                      d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(
-      m_physicalDevice, pTimeDomainCount, reinterpret_cast<VkTimeDomainEXT *>( pTimeDomains ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename TimeDomainEXTAllocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
-    typename ResultValueType<std::vector<TimeDomainEXT, TimeDomainEXTAllocator>>::type
-    PhysicalDevice::getCalibrateableTimeDomainsEXT( Dispatch const & d ) const
-  {
-    std::vector<TimeDomainEXT, TimeDomainEXTAllocator> timeDomains;
-    uint32_t                                           timeDomainCount;
-    Result                                             result;
-    do
-    {
-      result = static_cast<Result>(
-        d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, &timeDomainCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && timeDomainCount )
-      {
-        timeDomains.resize( timeDomainCount );
-        result = static_cast<Result>( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(
-          m_physicalDevice, &timeDomainCount, reinterpret_cast<VkTimeDomainEXT *>( timeDomains.data() ) ) );
-        VULKAN_HPP_ASSERT( timeDomainCount <= timeDomains.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( timeDomainCount < timeDomains.size() ) )
-    {
-      timeDomains.resize( timeDomainCount );
-    }
-    return createResultValue(
-      result, timeDomains, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCalibrateableTimeDomainsEXT" );
-  }
-
-  template <typename TimeDomainEXTAllocator,
-            typename Dispatch,
-            typename B,
-            typename std::enable_if<std::is_same<typename B::value_type, TimeDomainEXT>::value, int>::type>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
-    typename ResultValueType<std::vector<TimeDomainEXT, TimeDomainEXTAllocator>>::type
-    PhysicalDevice::getCalibrateableTimeDomainsEXT( TimeDomainEXTAllocator & timeDomainEXTAllocator,
-                                                    Dispatch const &         d ) const
-  {
-    std::vector<TimeDomainEXT, TimeDomainEXTAllocator> timeDomains( timeDomainEXTAllocator );
-    uint32_t                                           timeDomainCount;
-    Result                                             result;
-    do
-    {
-      result = static_cast<Result>(
-        d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, &timeDomainCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && timeDomainCount )
-      {
-        timeDomains.resize( timeDomainCount );
-        result = static_cast<Result>( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(
-          m_physicalDevice, &timeDomainCount, reinterpret_cast<VkTimeDomainEXT *>( timeDomains.data() ) ) );
-        VULKAN_HPP_ASSERT( timeDomainCount <= timeDomains.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( timeDomainCount < timeDomains.size() ) )
-    {
-      timeDomains.resize( timeDomainCount );
-    }
-    return createResultValue(
-      result, timeDomains, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCalibrateableTimeDomainsEXT" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    PhysicalDevice::getCooperativeMatrixPropertiesNV( uint32_t * pPropertyCount,
-                                                      VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV * pProperties,
-                                                      Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(
-      m_physicalDevice, pPropertyCount, reinterpret_cast<VkCooperativeMatrixPropertiesNV *>( pProperties ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename CooperativeMatrixPropertiesNVAllocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
-    typename ResultValueType<std::vector<CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator>>::type
-    PhysicalDevice::getCooperativeMatrixPropertiesNV( Dispatch const & d ) const
-  {
-    std::vector<CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator> properties;
-    uint32_t                                                                           propertyCount;
-    Result                                                                             result;
-    do
-    {
-      result = static_cast<Result>(
-        d.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( m_physicalDevice, &propertyCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && propertyCount )
-      {
-        properties.resize( propertyCount );
-        result = static_cast<Result>( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(
-          m_physicalDevice,
-          &propertyCount,
-          reinterpret_cast<VkCooperativeMatrixPropertiesNV *>( properties.data() ) ) );
-        VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) )
-    {
-      properties.resize( propertyCount );
-    }
-    return createResultValue(
-      result, properties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCooperativeMatrixPropertiesNV" );
-  }
-
-  template <
-    typename CooperativeMatrixPropertiesNVAllocator,
-    typename Dispatch,
-    typename B,
-    typename std::enable_if<std::is_same<typename B::value_type, CooperativeMatrixPropertiesNV>::value, int>::type>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
-    typename ResultValueType<std::vector<CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator>>::type
-    PhysicalDevice::getCooperativeMatrixPropertiesNV(
-      CooperativeMatrixPropertiesNVAllocator & cooperativeMatrixPropertiesNVAllocator, Dispatch const & d ) const
-  {
-    std::vector<CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator> properties(
-      cooperativeMatrixPropertiesNVAllocator );
-    uint32_t propertyCount;
-    Result   result;
-    do
-    {
-      result = static_cast<Result>(
-        d.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( m_physicalDevice, &propertyCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && propertyCount )
-      {
-        properties.resize( propertyCount );
-        result = static_cast<Result>( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(
-          m_physicalDevice,
-          &propertyCount,
-          reinterpret_cast<VkCooperativeMatrixPropertiesNV *>( properties.data() ) ) );
-        VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) )
-    {
-      properties.resize( propertyCount );
-    }
-    return createResultValue(
-      result, properties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCooperativeMatrixPropertiesNV" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE Bool32 PhysicalDevice::getDirectFBPresentationSupportEXT(
-    uint32_t queueFamilyIndex, IDirectFB * dfb, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Bool32>(
-      d.vkGetPhysicalDeviceDirectFBPresentationSupportEXT( m_physicalDevice, queueFamilyIndex, dfb ) );
-  }
-
-#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE Bool32 PhysicalDevice::getDirectFBPresentationSupportEXT(
-    uint32_t queueFamilyIndex, IDirectFB & dfb, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return d.vkGetPhysicalDeviceDirectFBPresentationSupportEXT( m_physicalDevice, queueFamilyIndex, &dfb );
-  }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_USE_PLATFORM_DIRECTFB_EXT*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    PhysicalDevice::getDisplayPlaneProperties2KHR( uint32_t *                                         pPropertyCount,
-                                                   VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR * pProperties,
-                                                   Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR(
-      m_physicalDevice, pPropertyCount, reinterpret_cast<VkDisplayPlaneProperties2KHR *>( pProperties ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename DisplayPlaneProperties2KHRAllocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
-    typename ResultValueType<std::vector<DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator>>::type
-    PhysicalDevice::getDisplayPlaneProperties2KHR( Dispatch const & d ) const
-  {
-    std::vector<DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator> properties;
-    uint32_t                                                                     propertyCount;
-    Result                                                                       result;
-    do
-    {
-      result = static_cast<Result>(
-        d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR( m_physicalDevice, &propertyCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && propertyCount )
-      {
-        properties.resize( propertyCount );
-        result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR(
-          m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPlaneProperties2KHR *>( properties.data() ) ) );
-        VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) )
-    {
-      properties.resize( propertyCount );
-    }
-    return createResultValue(
-      result, properties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneProperties2KHR" );
-  }
-
-  template <typename DisplayPlaneProperties2KHRAllocator,
-            typename Dispatch,
-            typename B,
-            typename std::enable_if<std::is_same<typename B::value_type, DisplayPlaneProperties2KHR>::value, int>::type>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
-    typename ResultValueType<std::vector<DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator>>::type
-    PhysicalDevice::getDisplayPlaneProperties2KHR(
-      DisplayPlaneProperties2KHRAllocator & displayPlaneProperties2KHRAllocator, Dispatch const & d ) const
-  {
-    std::vector<DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator> properties(
-      displayPlaneProperties2KHRAllocator );
-    uint32_t propertyCount;
-    Result   result;
-    do
-    {
-      result = static_cast<Result>(
-        d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR( m_physicalDevice, &propertyCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && propertyCount )
-      {
-        properties.resize( propertyCount );
-        result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR(
-          m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPlaneProperties2KHR *>( properties.data() ) ) );
-        VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) )
-    {
-      properties.resize( propertyCount );
-    }
-    return createResultValue(
-      result, properties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneProperties2KHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    PhysicalDevice::getDisplayPlanePropertiesKHR( uint32_t *                                        pPropertyCount,
-                                                  VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR * pProperties,
-                                                  Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
-      m_physicalDevice, pPropertyCount, reinterpret_cast<VkDisplayPlanePropertiesKHR *>( pProperties ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename DisplayPlanePropertiesKHRAllocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
-    typename ResultValueType<std::vector<DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator>>::type
-    PhysicalDevice::getDisplayPlanePropertiesKHR( Dispatch const & d ) const
-  {
-    std::vector<DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator> properties;
-    uint32_t                                                                   propertyCount;
-    Result                                                                     result;
-    do
-    {
-      result = static_cast<Result>(
-        d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && propertyCount )
-      {
-        properties.resize( propertyCount );
-        result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
-          m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPlanePropertiesKHR *>( properties.data() ) ) );
-        VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) )
-    {
-      properties.resize( propertyCount );
-    }
-    return createResultValue(
-      result, properties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlanePropertiesKHR" );
-  }
-
-  template <typename DisplayPlanePropertiesKHRAllocator,
-            typename Dispatch,
-            typename B,
-            typename std::enable_if<std::is_same<typename B::value_type, DisplayPlanePropertiesKHR>::value, int>::type>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
-    typename ResultValueType<std::vector<DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator>>::type
-    PhysicalDevice::getDisplayPlanePropertiesKHR(
-      DisplayPlanePropertiesKHRAllocator & displayPlanePropertiesKHRAllocator, Dispatch const & d ) const
-  {
-    std::vector<DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator> properties(
-      displayPlanePropertiesKHRAllocator );
-    uint32_t propertyCount;
-    Result   result;
-    do
-    {
-      result = static_cast<Result>(
-        d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && propertyCount )
-      {
-        properties.resize( propertyCount );
-        result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
-          m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPlanePropertiesKHR *>( properties.data() ) ) );
-        VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) )
-    {
-      properties.resize( propertyCount );
-    }
-    return createResultValue(
-      result, properties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlanePropertiesKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    PhysicalDevice::getDisplayProperties2KHR( uint32_t *                                    pPropertyCount,
-                                              VULKAN_HPP_NAMESPACE::DisplayProperties2KHR * pProperties,
-                                              Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkGetPhysicalDeviceDisplayProperties2KHR(
-      m_physicalDevice, pPropertyCount, reinterpret_cast<VkDisplayProperties2KHR *>( pProperties ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename DisplayProperties2KHRAllocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
-    typename ResultValueType<std::vector<DisplayProperties2KHR, DisplayProperties2KHRAllocator>>::type
-    PhysicalDevice::getDisplayProperties2KHR( Dispatch const & d ) const
-  {
-    std::vector<DisplayProperties2KHR, DisplayProperties2KHRAllocator> properties;
-    uint32_t                                                           propertyCount;
-    Result                                                             result;
-    do
-    {
-      result =
-        static_cast<Result>( d.vkGetPhysicalDeviceDisplayProperties2KHR( m_physicalDevice, &propertyCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && propertyCount )
-      {
-        properties.resize( propertyCount );
-        result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayProperties2KHR(
-          m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayProperties2KHR *>( properties.data() ) ) );
-        VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) )
-    {
-      properties.resize( propertyCount );
-    }
-    return createResultValue(
-      result, properties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayProperties2KHR" );
-  }
-
-  template <typename DisplayProperties2KHRAllocator,
-            typename Dispatch,
-            typename B,
-            typename std::enable_if<std::is_same<typename B::value_type, DisplayProperties2KHR>::value, int>::type>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
-    typename ResultValueType<std::vector<DisplayProperties2KHR, DisplayProperties2KHRAllocator>>::type
-    PhysicalDevice::getDisplayProperties2KHR( DisplayProperties2KHRAllocator & displayProperties2KHRAllocator,
-                                              Dispatch const &                 d ) const
-  {
-    std::vector<DisplayProperties2KHR, DisplayProperties2KHRAllocator> properties( displayProperties2KHRAllocator );
-    uint32_t                                                           propertyCount;
-    Result                                                             result;
-    do
-    {
-      result =
-        static_cast<Result>( d.vkGetPhysicalDeviceDisplayProperties2KHR( m_physicalDevice, &propertyCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && propertyCount )
-      {
-        properties.resize( propertyCount );
-        result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayProperties2KHR(
-          m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayProperties2KHR *>( properties.data() ) ) );
-        VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) )
-    {
-      properties.resize( propertyCount );
-    }
-    return createResultValue(
-      result, properties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayProperties2KHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    PhysicalDevice::getDisplayPropertiesKHR( uint32_t *                                   pPropertyCount,
-                                             VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR * pProperties,
-                                             Dispatch const &                             d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkGetPhysicalDeviceDisplayPropertiesKHR(
-      m_physicalDevice, pPropertyCount, reinterpret_cast<VkDisplayPropertiesKHR *>( pProperties ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename DisplayPropertiesKHRAllocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
-    typename ResultValueType<std::vector<DisplayPropertiesKHR, DisplayPropertiesKHRAllocator>>::type
-    PhysicalDevice::getDisplayPropertiesKHR( Dispatch const & d ) const
-  {
-    std::vector<DisplayPropertiesKHR, DisplayPropertiesKHRAllocator> properties;
-    uint32_t                                                         propertyCount;
-    Result                                                           result;
-    do
-    {
-      result =
-        static_cast<Result>( d.vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && propertyCount )
-      {
-        properties.resize( propertyCount );
-        result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPropertiesKHR(
-          m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPropertiesKHR *>( properties.data() ) ) );
-        VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) )
-    {
-      properties.resize( propertyCount );
-    }
-    return createResultValue(
-      result, properties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPropertiesKHR" );
-  }
-
-  template <typename DisplayPropertiesKHRAllocator,
-            typename Dispatch,
-            typename B,
-            typename std::enable_if<std::is_same<typename B::value_type, DisplayPropertiesKHR>::value, int>::type>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
-    typename ResultValueType<std::vector<DisplayPropertiesKHR, DisplayPropertiesKHRAllocator>>::type
-    PhysicalDevice::getDisplayPropertiesKHR( DisplayPropertiesKHRAllocator & displayPropertiesKHRAllocator,
-                                             Dispatch const &                d ) const
-  {
-    std::vector<DisplayPropertiesKHR, DisplayPropertiesKHRAllocator> properties( displayPropertiesKHRAllocator );
-    uint32_t                                                         propertyCount;
-    Result                                                           result;
-    do
-    {
-      result =
-        static_cast<Result>( d.vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && propertyCount )
-      {
-        properties.resize( propertyCount );
-        result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPropertiesKHR(
-          m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPropertiesKHR *>( properties.data() ) ) );
-        VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) )
-    {
-      properties.resize( propertyCount );
-    }
-    return createResultValue(
-      result, properties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPropertiesKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getExternalBufferProperties(
-    const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo * pExternalBufferInfo,
-    VULKAN_HPP_NAMESPACE::ExternalBufferProperties *               pExternalBufferProperties,
-    Dispatch const &                                               d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkGetPhysicalDeviceExternalBufferProperties(
-      m_physicalDevice,
-      reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo *>( pExternalBufferInfo ),
-      reinterpret_cast<VkExternalBufferProperties *>( pExternalBufferProperties ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalBufferProperties
-    PhysicalDevice::getExternalBufferProperties( const PhysicalDeviceExternalBufferInfo & externalBufferInfo,
-                                                 Dispatch const &                         d ) const VULKAN_HPP_NOEXCEPT
-  {
-    VULKAN_HPP_NAMESPACE::ExternalBufferProperties externalBufferProperties;
-    d.vkGetPhysicalDeviceExternalBufferProperties(
-      m_physicalDevice,
-      reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo *>( &externalBufferInfo ),
-      reinterpret_cast<VkExternalBufferProperties *>( &externalBufferProperties ) );
-    return externalBufferProperties;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getExternalBufferPropertiesKHR(
-    const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo * pExternalBufferInfo,
-    VULKAN_HPP_NAMESPACE::ExternalBufferProperties *               pExternalBufferProperties,
-    Dispatch const &                                               d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkGetPhysicalDeviceExternalBufferPropertiesKHR(
-      m_physicalDevice,
-      reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo *>( pExternalBufferInfo ),
-      reinterpret_cast<VkExternalBufferProperties *>( pExternalBufferProperties ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalBufferProperties
-    PhysicalDevice::getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfo & externalBufferInfo,
-                                                    Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    VULKAN_HPP_NAMESPACE::ExternalBufferProperties externalBufferProperties;
-    d.vkGetPhysicalDeviceExternalBufferPropertiesKHR(
-      m_physicalDevice,
-      reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo *>( &externalBufferInfo ),
-      reinterpret_cast<VkExternalBufferProperties *>( &externalBufferProperties ) );
-    return externalBufferProperties;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getExternalFenceProperties(
-    const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo * pExternalFenceInfo,
-    VULKAN_HPP_NAMESPACE::ExternalFenceProperties *               pExternalFenceProperties,
-    Dispatch const &                                              d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkGetPhysicalDeviceExternalFenceProperties(
-      m_physicalDevice,
-      reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo *>( pExternalFenceInfo ),
-      reinterpret_cast<VkExternalFenceProperties *>( pExternalFenceProperties ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalFenceProperties
-    PhysicalDevice::getExternalFenceProperties( const PhysicalDeviceExternalFenceInfo & externalFenceInfo,
-                                                Dispatch const &                        d ) const VULKAN_HPP_NOEXCEPT
-  {
-    VULKAN_HPP_NAMESPACE::ExternalFenceProperties externalFenceProperties;
-    d.vkGetPhysicalDeviceExternalFenceProperties(
-      m_physicalDevice,
-      reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo *>( &externalFenceInfo ),
-      reinterpret_cast<VkExternalFenceProperties *>( &externalFenceProperties ) );
-    return externalFenceProperties;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getExternalFencePropertiesKHR(
-    const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo * pExternalFenceInfo,
-    VULKAN_HPP_NAMESPACE::ExternalFenceProperties *               pExternalFenceProperties,
-    Dispatch const &                                              d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkGetPhysicalDeviceExternalFencePropertiesKHR(
-      m_physicalDevice,
-      reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo *>( pExternalFenceInfo ),
-      reinterpret_cast<VkExternalFenceProperties *>( pExternalFenceProperties ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalFenceProperties
-    PhysicalDevice::getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfo & externalFenceInfo,
-                                                   Dispatch const &                        d ) const VULKAN_HPP_NOEXCEPT
-  {
-    VULKAN_HPP_NAMESPACE::ExternalFenceProperties externalFenceProperties;
-    d.vkGetPhysicalDeviceExternalFencePropertiesKHR(
-      m_physicalDevice,
-      reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo *>( &externalFenceInfo ),
-      reinterpret_cast<VkExternalFenceProperties *>( &externalFenceProperties ) );
-    return externalFenceProperties;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getExternalImageFormatPropertiesNV(
-    VULKAN_HPP_NAMESPACE::Format                            format,
-    VULKAN_HPP_NAMESPACE::ImageType                         type,
-    VULKAN_HPP_NAMESPACE::ImageTiling                       tiling,
-    VULKAN_HPP_NAMESPACE::ImageUsageFlags                   usage,
-    VULKAN_HPP_NAMESPACE::ImageCreateFlags                  flags,
-    VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV   externalHandleType,
-    VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV * pExternalImageFormatProperties,
-    Dispatch const &                                        d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
-      m_physicalDevice,
-      static_cast<VkFormat>( format ),
-      static_cast<VkImageType>( type ),
-      static_cast<VkImageTiling>( tiling ),
-      static_cast<VkImageUsageFlags>( usage ),
-      static_cast<VkImageCreateFlags>( flags ),
-      static_cast<VkExternalMemoryHandleTypeFlagsNV>( externalHandleType ),
-      reinterpret_cast<VkExternalImageFormatPropertiesNV *>( pExternalImageFormatProperties ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV>::type
-    PhysicalDevice::getExternalImageFormatPropertiesNV(
-      VULKAN_HPP_NAMESPACE::Format                          format,
-      VULKAN_HPP_NAMESPACE::ImageType                       type,
-      VULKAN_HPP_NAMESPACE::ImageTiling                     tiling,
-      VULKAN_HPP_NAMESPACE::ImageUsageFlags                 usage,
-      VULKAN_HPP_NAMESPACE::ImageCreateFlags                flags,
-      VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV externalHandleType,
-      Dispatch const &                                      d ) const
-  {
-    VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV externalImageFormatProperties;
-    Result result = static_cast<Result>( d.vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
-      m_physicalDevice,
-      static_cast<VkFormat>( format ),
-      static_cast<VkImageType>( type ),
-      static_cast<VkImageTiling>( tiling ),
-      static_cast<VkImageUsageFlags>( usage ),
-      static_cast<VkImageCreateFlags>( flags ),
-      static_cast<VkExternalMemoryHandleTypeFlagsNV>( externalHandleType ),
-      reinterpret_cast<VkExternalImageFormatPropertiesNV *>( &externalImageFormatProperties ) ) );
-    return createResultValue( result,
-                              externalImageFormatProperties,
-                              VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getExternalImageFormatPropertiesNV" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getExternalSemaphoreProperties(
-    const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,
-    VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties *               pExternalSemaphoreProperties,
-    Dispatch const &                                                  d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkGetPhysicalDeviceExternalSemaphoreProperties(
-      m_physicalDevice,
-      reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo *>( pExternalSemaphoreInfo ),
-      reinterpret_cast<VkExternalSemaphoreProperties *>( pExternalSemaphoreProperties ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties
-    PhysicalDevice::getExternalSemaphoreProperties( const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo,
-                                                    Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties externalSemaphoreProperties;
-    d.vkGetPhysicalDeviceExternalSemaphoreProperties(
-      m_physicalDevice,
-      reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo *>( &externalSemaphoreInfo ),
-      reinterpret_cast<VkExternalSemaphoreProperties *>( &externalSemaphoreProperties ) );
-    return externalSemaphoreProperties;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getExternalSemaphorePropertiesKHR(
-    const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,
-    VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties *               pExternalSemaphoreProperties,
-    Dispatch const &                                                  d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
-      m_physicalDevice,
-      reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo *>( pExternalSemaphoreInfo ),
-      reinterpret_cast<VkExternalSemaphoreProperties *>( pExternalSemaphoreProperties ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties
-                                         PhysicalDevice::getExternalSemaphorePropertiesKHR(
-      const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties externalSemaphoreProperties;
-    d.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
-      m_physicalDevice,
-      reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo *>( &externalSemaphoreInfo ),
-      reinterpret_cast<VkExternalSemaphoreProperties *>( &externalSemaphoreProperties ) );
-    return externalSemaphoreProperties;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getFeatures( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures * pFeatures,
-                                                      Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkGetPhysicalDeviceFeatures( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures *>( pFeatures ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures
-                                         PhysicalDevice::getFeatures( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures features;
-    d.vkGetPhysicalDeviceFeatures( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures *>( &features ) );
-    return features;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getFeatures2( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 * pFeatures,
-                                                       Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkGetPhysicalDeviceFeatures2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2 *>( pFeatures ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2
-                                         PhysicalDevice::getFeatures2( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 features;
-    d.vkGetPhysicalDeviceFeatures2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2 *>( &features ) );
-    return features;
-  }
-
-  template <typename X, typename Y, typename... Z, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
-                                         PhysicalDevice::getFeatures2( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    StructureChain<X, Y, Z...>                      structureChain;
-    VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 & features =
-      structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2>();
-    d.vkGetPhysicalDeviceFeatures2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2 *>( &features ) );
-    return structureChain;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getFeatures2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 * pFeatures,
-                                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2 *>( pFeatures ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2
-                                         PhysicalDevice::getFeatures2KHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 features;
-    d.vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2 *>( &features ) );
-    return features;
-  }
-
-  template <typename X, typename Y, typename... Z, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
-                                         PhysicalDevice::getFeatures2KHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    StructureChain<X, Y, Z...>                      structureChain;
-    VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 & features =
-      structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2>();
-    d.vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2 *>( &features ) );
-    return structureChain;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    PhysicalDevice::getFormatProperties( VULKAN_HPP_NAMESPACE::Format             format,
-                                         VULKAN_HPP_NAMESPACE::FormatProperties * pFormatProperties,
-                                         Dispatch const &                         d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkGetPhysicalDeviceFormatProperties(
-      m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties *>( pFormatProperties ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::FormatProperties
-                                         PhysicalDevice::getFormatProperties( VULKAN_HPP_NAMESPACE::Format format,
-                                         Dispatch const &             d ) const VULKAN_HPP_NOEXCEPT
-  {
-    VULKAN_HPP_NAMESPACE::FormatProperties formatProperties;
-    d.vkGetPhysicalDeviceFormatProperties(
-      m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties *>( &formatProperties ) );
-    return formatProperties;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    PhysicalDevice::getFormatProperties2( VULKAN_HPP_NAMESPACE::Format              format,
-                                          VULKAN_HPP_NAMESPACE::FormatProperties2 * pFormatProperties,
-                                          Dispatch const &                          d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkGetPhysicalDeviceFormatProperties2(
-      m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2 *>( pFormatProperties ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::FormatProperties2
-                                         PhysicalDevice::getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format,
-                                          Dispatch const &             d ) const VULKAN_HPP_NOEXCEPT
-  {
-    VULKAN_HPP_NAMESPACE::FormatProperties2 formatProperties;
-    d.vkGetPhysicalDeviceFormatProperties2(
-      m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2 *>( &formatProperties ) );
-    return formatProperties;
-  }
-
-  template <typename X, typename Y, typename... Z, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
-                                         PhysicalDevice::getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format,
-                                          Dispatch const &             d ) const VULKAN_HPP_NOEXCEPT
-  {
-    StructureChain<X, Y, Z...>                structureChain;
-    VULKAN_HPP_NAMESPACE::FormatProperties2 & formatProperties =
-      structureChain.template get<VULKAN_HPP_NAMESPACE::FormatProperties2>();
-    d.vkGetPhysicalDeviceFormatProperties2(
-      m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2 *>( &formatProperties ) );
-    return structureChain;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    PhysicalDevice::getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format              format,
-                                             VULKAN_HPP_NAMESPACE::FormatProperties2 * pFormatProperties,
-                                             Dispatch const &                          d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkGetPhysicalDeviceFormatProperties2KHR(
-      m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2 *>( pFormatProperties ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::FormatProperties2
-                                         PhysicalDevice::getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format,
-                                             Dispatch const &             d ) const VULKAN_HPP_NOEXCEPT
-  {
-    VULKAN_HPP_NAMESPACE::FormatProperties2 formatProperties;
-    d.vkGetPhysicalDeviceFormatProperties2KHR(
-      m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2 *>( &formatProperties ) );
-    return formatProperties;
-  }
-
-  template <typename X, typename Y, typename... Z, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
-                                         PhysicalDevice::getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format,
-                                             Dispatch const &             d ) const VULKAN_HPP_NOEXCEPT
-  {
-    StructureChain<X, Y, Z...>                structureChain;
-    VULKAN_HPP_NAMESPACE::FormatProperties2 & formatProperties =
-      structureChain.template get<VULKAN_HPP_NAMESPACE::FormatProperties2>();
-    d.vkGetPhysicalDeviceFormatProperties2KHR(
-      m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2 *>( &formatProperties ) );
-    return structureChain;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getFragmentShadingRatesKHR(
-    uint32_t *                                                   pFragmentShadingRateCount,
-    VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR * pFragmentShadingRates,
-    Dispatch const &                                             d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkGetPhysicalDeviceFragmentShadingRatesKHR(
-      m_physicalDevice,
-      pFragmentShadingRateCount,
-      reinterpret_cast<VkPhysicalDeviceFragmentShadingRateKHR *>( pFragmentShadingRates ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename PhysicalDeviceFragmentShadingRateKHRAllocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<
-    std::vector<PhysicalDeviceFragmentShadingRateKHR, PhysicalDeviceFragmentShadingRateKHRAllocator>>::type
-    PhysicalDevice::getFragmentShadingRatesKHR( Dispatch const & d ) const
-  {
-    std::vector<PhysicalDeviceFragmentShadingRateKHR, PhysicalDeviceFragmentShadingRateKHRAllocator>
-             fragmentShadingRates;
-    uint32_t fragmentShadingRateCount;
-    Result   result;
-    do
-    {
-      result = static_cast<Result>(
-        d.vkGetPhysicalDeviceFragmentShadingRatesKHR( m_physicalDevice, &fragmentShadingRateCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && fragmentShadingRateCount )
-      {
-        fragmentShadingRates.resize( fragmentShadingRateCount );
-        result = static_cast<Result>( d.vkGetPhysicalDeviceFragmentShadingRatesKHR(
-          m_physicalDevice,
-          &fragmentShadingRateCount,
-          reinterpret_cast<VkPhysicalDeviceFragmentShadingRateKHR *>( fragmentShadingRates.data() ) ) );
-        VULKAN_HPP_ASSERT( fragmentShadingRateCount <= fragmentShadingRates.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( fragmentShadingRateCount < fragmentShadingRates.size() ) )
-    {
-      fragmentShadingRates.resize( fragmentShadingRateCount );
-    }
-    return createResultValue(
-      result, fragmentShadingRates, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getFragmentShadingRatesKHR" );
-  }
-
-  template <typename PhysicalDeviceFragmentShadingRateKHRAllocator,
-            typename Dispatch,
-            typename B,
-            typename std::enable_if<std::is_same<typename B::value_type, PhysicalDeviceFragmentShadingRateKHR>::value,
-                                    int>::type>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<
-    std::vector<PhysicalDeviceFragmentShadingRateKHR, PhysicalDeviceFragmentShadingRateKHRAllocator>>::type
-    PhysicalDevice::getFragmentShadingRatesKHR(
-      PhysicalDeviceFragmentShadingRateKHRAllocator & physicalDeviceFragmentShadingRateKHRAllocator,
-      Dispatch const &                                d ) const
-  {
-    std::vector<PhysicalDeviceFragmentShadingRateKHR, PhysicalDeviceFragmentShadingRateKHRAllocator>
-             fragmentShadingRates( physicalDeviceFragmentShadingRateKHRAllocator );
-    uint32_t fragmentShadingRateCount;
-    Result   result;
-    do
-    {
-      result = static_cast<Result>(
-        d.vkGetPhysicalDeviceFragmentShadingRatesKHR( m_physicalDevice, &fragmentShadingRateCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && fragmentShadingRateCount )
-      {
-        fragmentShadingRates.resize( fragmentShadingRateCount );
-        result = static_cast<Result>( d.vkGetPhysicalDeviceFragmentShadingRatesKHR(
-          m_physicalDevice,
-          &fragmentShadingRateCount,
-          reinterpret_cast<VkPhysicalDeviceFragmentShadingRateKHR *>( fragmentShadingRates.data() ) ) );
-        VULKAN_HPP_ASSERT( fragmentShadingRateCount <= fragmentShadingRates.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( fragmentShadingRateCount < fragmentShadingRates.size() ) )
-    {
-      fragmentShadingRates.resize( fragmentShadingRateCount );
-    }
-    return createResultValue(
-      result, fragmentShadingRates, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getFragmentShadingRatesKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    PhysicalDevice::getImageFormatProperties( VULKAN_HPP_NAMESPACE::Format                  format,
-                                              VULKAN_HPP_NAMESPACE::ImageType               type,
-                                              VULKAN_HPP_NAMESPACE::ImageTiling             tiling,
-                                              VULKAN_HPP_NAMESPACE::ImageUsageFlags         usage,
-                                              VULKAN_HPP_NAMESPACE::ImageCreateFlags        flags,
-                                              VULKAN_HPP_NAMESPACE::ImageFormatProperties * pImageFormatProperties,
-                                              Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties(
-      m_physicalDevice,
-      static_cast<VkFormat>( format ),
-      static_cast<VkImageType>( type ),
-      static_cast<VkImageTiling>( tiling ),
-      static_cast<VkImageUsageFlags>( usage ),
-      static_cast<VkImageCreateFlags>( flags ),
-      reinterpret_cast<VkImageFormatProperties *>( pImageFormatProperties ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageFormatProperties>::type
-    PhysicalDevice::getImageFormatProperties( VULKAN_HPP_NAMESPACE::Format           format,
-                                              VULKAN_HPP_NAMESPACE::ImageType        type,
-                                              VULKAN_HPP_NAMESPACE::ImageTiling      tiling,
-                                              VULKAN_HPP_NAMESPACE::ImageUsageFlags  usage,
-                                              VULKAN_HPP_NAMESPACE::ImageCreateFlags flags,
-                                              Dispatch const &                       d ) const
-  {
-    VULKAN_HPP_NAMESPACE::ImageFormatProperties imageFormatProperties;
-    Result result = static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties(
-      m_physicalDevice,
-      static_cast<VkFormat>( format ),
-      static_cast<VkImageType>( type ),
-      static_cast<VkImageTiling>( tiling ),
-      static_cast<VkImageUsageFlags>( usage ),
-      static_cast<VkImageCreateFlags>( flags ),
-      reinterpret_cast<VkImageFormatProperties *>( &imageFormatProperties ) ) );
-    return createResultValue(
-      result, imageFormatProperties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getImageFormatProperties2(
-    const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 * pImageFormatInfo,
-    VULKAN_HPP_NAMESPACE::ImageFormatProperties2 *               pImageFormatProperties,
-    Dispatch const &                                             d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2(
-      m_physicalDevice,
-      reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( pImageFormatInfo ),
-      reinterpret_cast<VkImageFormatProperties2 *>( pImageFormatProperties ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>::type
-    PhysicalDevice::getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo,
-                                               Dispatch const &                       d ) const
-  {
-    VULKAN_HPP_NAMESPACE::ImageFormatProperties2 imageFormatProperties;
-    Result result = static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2(
-      m_physicalDevice,
-      reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( &imageFormatInfo ),
-      reinterpret_cast<VkImageFormatProperties2 *>( &imageFormatProperties ) ) );
-    return createResultValue(
-      result, imageFormatProperties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2" );
-  }
-
-  template <typename X, typename Y, typename... Z, typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<StructureChain<X, Y, Z...>>::type
-    PhysicalDevice::getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo,
-                                               Dispatch const &                       d ) const
-  {
-    StructureChain<X, Y, Z...>                     structureChain;
-    VULKAN_HPP_NAMESPACE::ImageFormatProperties2 & imageFormatProperties =
-      structureChain.template get<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>();
-    Result result = static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2(
-      m_physicalDevice,
-      reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( &imageFormatInfo ),
-      reinterpret_cast<VkImageFormatProperties2 *>( &imageFormatProperties ) ) );
-    return createResultValue(
-      result, structureChain, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getImageFormatProperties2KHR(
-    const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 * pImageFormatInfo,
-    VULKAN_HPP_NAMESPACE::ImageFormatProperties2 *               pImageFormatProperties,
-    Dispatch const &                                             d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2KHR(
-      m_physicalDevice,
-      reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( pImageFormatInfo ),
-      reinterpret_cast<VkImageFormatProperties2 *>( pImageFormatProperties ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>::type
-    PhysicalDevice::getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo,
-                                                  Dispatch const &                       d ) const
-  {
-    VULKAN_HPP_NAMESPACE::ImageFormatProperties2 imageFormatProperties;
-    Result result = static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2KHR(
-      m_physicalDevice,
-      reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( &imageFormatInfo ),
-      reinterpret_cast<VkImageFormatProperties2 *>( &imageFormatProperties ) ) );
-    return createResultValue(
-      result, imageFormatProperties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2KHR" );
-  }
-
-  template <typename X, typename Y, typename... Z, typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<StructureChain<X, Y, Z...>>::type
-    PhysicalDevice::getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo,
-                                                  Dispatch const &                       d ) const
-  {
-    StructureChain<X, Y, Z...>                     structureChain;
-    VULKAN_HPP_NAMESPACE::ImageFormatProperties2 & imageFormatProperties =
-      structureChain.template get<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>();
-    Result result = static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2KHR(
-      m_physicalDevice,
-      reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( &imageFormatInfo ),
-      reinterpret_cast<VkImageFormatProperties2 *>( &imageFormatProperties ) ) );
-    return createResultValue(
-      result, structureChain, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2KHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    PhysicalDevice::getMemoryProperties( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties * pMemoryProperties,
-                                         Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkGetPhysicalDeviceMemoryProperties( m_physicalDevice,
-                                           reinterpret_cast<VkPhysicalDeviceMemoryProperties *>( pMemoryProperties ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties
-    PhysicalDevice::getMemoryProperties( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties memoryProperties;
-    d.vkGetPhysicalDeviceMemoryProperties( m_physicalDevice,
-                                           reinterpret_cast<VkPhysicalDeviceMemoryProperties *>( &memoryProperties ) );
-    return memoryProperties;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    PhysicalDevice::getMemoryProperties2( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 * pMemoryProperties,
-                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkGetPhysicalDeviceMemoryProperties2(
-      m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( pMemoryProperties ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2
-    PhysicalDevice::getMemoryProperties2( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 memoryProperties;
-    d.vkGetPhysicalDeviceMemoryProperties2(
-      m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( &memoryProperties ) );
-    return memoryProperties;
-  }
-
-  template <typename X, typename Y, typename... Z, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
-    PhysicalDevice::getMemoryProperties2( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    StructureChain<X, Y, Z...>                              structureChain;
-    VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 & memoryProperties =
-      structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2>();
-    d.vkGetPhysicalDeviceMemoryProperties2(
-      m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( &memoryProperties ) );
-    return structureChain;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    PhysicalDevice::getMemoryProperties2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 * pMemoryProperties,
-                                             Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkGetPhysicalDeviceMemoryProperties2KHR(
-      m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( pMemoryProperties ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2
-    PhysicalDevice::getMemoryProperties2KHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 memoryProperties;
-    d.vkGetPhysicalDeviceMemoryProperties2KHR(
-      m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( &memoryProperties ) );
-    return memoryProperties;
-  }
-
-  template <typename X, typename Y, typename... Z, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
-    PhysicalDevice::getMemoryProperties2KHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    StructureChain<X, Y, Z...>                              structureChain;
-    VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 & memoryProperties =
-      structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2>();
-    d.vkGetPhysicalDeviceMemoryProperties2KHR(
-      m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( &memoryProperties ) );
-    return structureChain;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getMultisamplePropertiesEXT(
-    VULKAN_HPP_NAMESPACE::SampleCountFlagBits        samples,
-    VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT * pMultisampleProperties,
-    Dispatch const &                                 d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkGetPhysicalDeviceMultisamplePropertiesEXT(
-      m_physicalDevice,
-      static_cast<VkSampleCountFlagBits>( samples ),
-      reinterpret_cast<VkMultisamplePropertiesEXT *>( pMultisampleProperties ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT
-    PhysicalDevice::getMultisamplePropertiesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,
-                                                 Dispatch const &                          d ) const VULKAN_HPP_NOEXCEPT
-  {
-    VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT multisampleProperties;
-    d.vkGetPhysicalDeviceMultisamplePropertiesEXT(
-      m_physicalDevice,
-      static_cast<VkSampleCountFlagBits>( samples ),
-      reinterpret_cast<VkMultisamplePropertiesEXT *>( &multisampleProperties ) );
-    return multisampleProperties;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    PhysicalDevice::getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
-                                             uint32_t *                       pRectCount,
-                                             VULKAN_HPP_NAMESPACE::Rect2D *   pRects,
-                                             Dispatch const &                 d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkGetPhysicalDevicePresentRectanglesKHR(
-      m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), pRectCount, reinterpret_cast<VkRect2D *>( pRects ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Rect2DAllocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<Rect2D, Rect2DAllocator>>::type
-    PhysicalDevice::getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d ) const
-  {
-    std::vector<Rect2D, Rect2DAllocator> rects;
-    uint32_t                             rectCount;
-    Result                               result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetPhysicalDevicePresentRectanglesKHR(
-        m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &rectCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && rectCount )
-      {
-        rects.resize( rectCount );
-        result = static_cast<Result>(
-          d.vkGetPhysicalDevicePresentRectanglesKHR( m_physicalDevice,
-                                                     static_cast<VkSurfaceKHR>( surface ),
-                                                     &rectCount,
-                                                     reinterpret_cast<VkRect2D *>( rects.data() ) ) );
-        VULKAN_HPP_ASSERT( rectCount <= rects.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( rectCount < rects.size() ) )
-    {
-      rects.resize( rectCount );
-    }
-    return createResultValue( result, rects, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getPresentRectanglesKHR" );
-  }
-
-  template <typename Rect2DAllocator,
-            typename Dispatch,
-            typename B,
-            typename std::enable_if<std::is_same<typename B::value_type, Rect2D>::value, int>::type>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<Rect2D, Rect2DAllocator>>::type
-                       PhysicalDevice::getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
-                                             Rect2DAllocator &                rect2DAllocator,
-                                             Dispatch const &                 d ) const
-  {
-    std::vector<Rect2D, Rect2DAllocator> rects( rect2DAllocator );
-    uint32_t                             rectCount;
-    Result                               result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetPhysicalDevicePresentRectanglesKHR(
-        m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &rectCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && rectCount )
-      {
-        rects.resize( rectCount );
-        result = static_cast<Result>(
-          d.vkGetPhysicalDevicePresentRectanglesKHR( m_physicalDevice,
-                                                     static_cast<VkSurfaceKHR>( surface ),
-                                                     &rectCount,
-                                                     reinterpret_cast<VkRect2D *>( rects.data() ) ) );
-        VULKAN_HPP_ASSERT( rectCount <= rects.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( rectCount < rects.size() ) )
-    {
-      rects.resize( rectCount );
-    }
-    return createResultValue( result, rects, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getPresentRectanglesKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getProperties( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties * pProperties,
-                                                        Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkGetPhysicalDeviceProperties( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties *>( pProperties ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties
-                                         PhysicalDevice::getProperties( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties properties;
-    d.vkGetPhysicalDeviceProperties( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties *>( &properties ) );
-    return properties;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getProperties2( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 * pProperties,
-                                                         Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkGetPhysicalDeviceProperties2( m_physicalDevice,
-                                      reinterpret_cast<VkPhysicalDeviceProperties2 *>( pProperties ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2
-                                         PhysicalDevice::getProperties2( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 properties;
-    d.vkGetPhysicalDeviceProperties2( m_physicalDevice,
-                                      reinterpret_cast<VkPhysicalDeviceProperties2 *>( &properties ) );
-    return properties;
-  }
-
-  template <typename X, typename Y, typename... Z, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
-                                         PhysicalDevice::getProperties2( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    StructureChain<X, Y, Z...>                        structureChain;
-    VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 & properties =
-      structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2>();
-    d.vkGetPhysicalDeviceProperties2( m_physicalDevice,
-                                      reinterpret_cast<VkPhysicalDeviceProperties2 *>( &properties ) );
-    return structureChain;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    PhysicalDevice::getProperties2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 * pProperties,
-                                       Dispatch const &                                  d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkGetPhysicalDeviceProperties2KHR( m_physicalDevice,
-                                         reinterpret_cast<VkPhysicalDeviceProperties2 *>( pProperties ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2
-    PhysicalDevice::getProperties2KHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 properties;
-    d.vkGetPhysicalDeviceProperties2KHR( m_physicalDevice,
-                                         reinterpret_cast<VkPhysicalDeviceProperties2 *>( &properties ) );
-    return properties;
-  }
-
-  template <typename X, typename Y, typename... Z, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
-    PhysicalDevice::getProperties2KHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    StructureChain<X, Y, Z...>                        structureChain;
-    VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 & properties =
-      structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2>();
-    d.vkGetPhysicalDeviceProperties2KHR( m_physicalDevice,
-                                         reinterpret_cast<VkPhysicalDeviceProperties2 *>( &properties ) );
-    return structureChain;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyPerformanceQueryPassesKHR(
-    const VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR * pPerformanceQueryCreateInfo,
-    uint32_t *                                                      pNumPasses,
-    Dispatch const &                                                d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(
-      m_physicalDevice,
-      reinterpret_cast<const VkQueryPoolPerformanceCreateInfoKHR *>( pPerformanceQueryCreateInfo ),
-      pNumPasses );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint32_t PhysicalDevice::getQueueFamilyPerformanceQueryPassesKHR(
-    const QueryPoolPerformanceCreateInfoKHR & performanceQueryCreateInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    uint32_t numPasses;
-    d.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(
-      m_physicalDevice,
-      reinterpret_cast<const VkQueryPoolPerformanceCreateInfoKHR *>( &performanceQueryCreateInfo ),
-      &numPasses );
-    return numPasses;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    PhysicalDevice::getQueueFamilyProperties( uint32_t *                                    pQueueFamilyPropertyCount,
-                                              VULKAN_HPP_NAMESPACE::QueueFamilyProperties * pQueueFamilyProperties,
-                                              Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkGetPhysicalDeviceQueueFamilyProperties( m_physicalDevice,
-                                                pQueueFamilyPropertyCount,
-                                                reinterpret_cast<VkQueueFamilyProperties *>( pQueueFamilyProperties ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename QueueFamilyPropertiesAllocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<QueueFamilyProperties, QueueFamilyPropertiesAllocator>
-                                         PhysicalDevice::getQueueFamilyProperties( Dispatch const & d ) const
-  {
-    std::vector<QueueFamilyProperties, QueueFamilyPropertiesAllocator> queueFamilyProperties;
-    uint32_t                                                           queueFamilyPropertyCount;
-    d.vkGetPhysicalDeviceQueueFamilyProperties( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
-    queueFamilyProperties.resize( queueFamilyPropertyCount );
-    d.vkGetPhysicalDeviceQueueFamilyProperties(
-      m_physicalDevice,
-      &queueFamilyPropertyCount,
-      reinterpret_cast<VkQueueFamilyProperties *>( queueFamilyProperties.data() ) );
-    VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() );
-    return queueFamilyProperties;
-  }
-
-  template <typename QueueFamilyPropertiesAllocator,
-            typename Dispatch,
-            typename B,
-            typename std::enable_if<std::is_same<typename B::value_type, QueueFamilyProperties>::value, int>::type>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<QueueFamilyProperties, QueueFamilyPropertiesAllocator>
-    PhysicalDevice::getQueueFamilyProperties( QueueFamilyPropertiesAllocator & queueFamilyPropertiesAllocator,
-                                              Dispatch const &                 d ) const
-  {
-    std::vector<QueueFamilyProperties, QueueFamilyPropertiesAllocator> queueFamilyProperties(
-      queueFamilyPropertiesAllocator );
-    uint32_t queueFamilyPropertyCount;
-    d.vkGetPhysicalDeviceQueueFamilyProperties( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
-    queueFamilyProperties.resize( queueFamilyPropertyCount );
-    d.vkGetPhysicalDeviceQueueFamilyProperties(
-      m_physicalDevice,
-      &queueFamilyPropertyCount,
-      reinterpret_cast<VkQueueFamilyProperties *>( queueFamilyProperties.data() ) );
-    VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() );
-    return queueFamilyProperties;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    PhysicalDevice::getQueueFamilyProperties2( uint32_t *                                     pQueueFamilyPropertyCount,
-                                               VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 * pQueueFamilyProperties,
-                                               Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkGetPhysicalDeviceQueueFamilyProperties2(
-      m_physicalDevice,
-      pQueueFamilyPropertyCount,
-      reinterpret_cast<VkQueueFamilyProperties2 *>( pQueueFamilyProperties ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename QueueFamilyProperties2Allocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator>
-                                         PhysicalDevice::getQueueFamilyProperties2( Dispatch const & d ) const
-  {
-    std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator> queueFamilyProperties;
-    uint32_t                                                             queueFamilyPropertyCount;
-    d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
-    queueFamilyProperties.resize( queueFamilyPropertyCount );
-    d.vkGetPhysicalDeviceQueueFamilyProperties2(
-      m_physicalDevice,
-      &queueFamilyPropertyCount,
-      reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) );
-    VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() );
-    return queueFamilyProperties;
-  }
-
-  template <typename QueueFamilyProperties2Allocator,
-            typename Dispatch,
-            typename B,
-            typename std::enable_if<std::is_same<typename B::value_type, QueueFamilyProperties2>::value, int>::type>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator>
-    PhysicalDevice::getQueueFamilyProperties2( QueueFamilyProperties2Allocator & queueFamilyProperties2Allocator,
-                                               Dispatch const &                  d ) const
-  {
-    std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator> queueFamilyProperties(
-      queueFamilyProperties2Allocator );
-    uint32_t queueFamilyPropertyCount;
-    d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
-    queueFamilyProperties.resize( queueFamilyPropertyCount );
-    d.vkGetPhysicalDeviceQueueFamilyProperties2(
-      m_physicalDevice,
-      &queueFamilyPropertyCount,
-      reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) );
-    VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() );
-    return queueFamilyProperties;
-  }
-
-  template <typename StructureChain, typename StructureChainAllocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<StructureChain, StructureChainAllocator>
-                                         PhysicalDevice::getQueueFamilyProperties2( Dispatch const & d ) const
-  {
-    uint32_t queueFamilyPropertyCount;
-    d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
-    std::vector<StructureChain, StructureChainAllocator>      returnVector( queueFamilyPropertyCount );
-    std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> queueFamilyProperties( queueFamilyPropertyCount );
-    for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ )
-    {
-      queueFamilyProperties[i].pNext =
-        returnVector[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>().pNext;
-    }
-    d.vkGetPhysicalDeviceQueueFamilyProperties2(
-      m_physicalDevice,
-      &queueFamilyPropertyCount,
-      reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) );
-    VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() );
-    for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ )
-    {
-      returnVector[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>() = queueFamilyProperties[i];
-    }
-    return returnVector;
-  }
-
-  template <typename StructureChain,
-            typename StructureChainAllocator,
-            typename Dispatch,
-            typename B,
-            typename std::enable_if<std::is_same<typename B::value_type, StructureChain>::value, int>::type>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<StructureChain, StructureChainAllocator>
-    PhysicalDevice::getQueueFamilyProperties2( StructureChainAllocator & structureChainAllocator,
-                                               Dispatch const &          d ) const
-  {
-    uint32_t queueFamilyPropertyCount;
-    d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
-    std::vector<StructureChain, StructureChainAllocator>      returnVector( queueFamilyPropertyCount,
-                                                                       structureChainAllocator );
-    std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> queueFamilyProperties( queueFamilyPropertyCount );
-    for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ )
-    {
-      queueFamilyProperties[i].pNext =
-        returnVector[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>().pNext;
-    }
-    d.vkGetPhysicalDeviceQueueFamilyProperties2(
-      m_physicalDevice,
-      &queueFamilyPropertyCount,
-      reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) );
-    VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() );
-    for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ )
-    {
-      returnVector[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>() = queueFamilyProperties[i];
-    }
-    return returnVector;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    PhysicalDevice::getQueueFamilyProperties2KHR( uint32_t * pQueueFamilyPropertyCount,
-                                                  VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 * pQueueFamilyProperties,
-                                                  Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkGetPhysicalDeviceQueueFamilyProperties2KHR(
-      m_physicalDevice,
-      pQueueFamilyPropertyCount,
-      reinterpret_cast<VkQueueFamilyProperties2 *>( pQueueFamilyProperties ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename QueueFamilyProperties2Allocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator>
-                                         PhysicalDevice::getQueueFamilyProperties2KHR( Dispatch const & d ) const
-  {
-    std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator> queueFamilyProperties;
-    uint32_t                                                             queueFamilyPropertyCount;
-    d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
-    queueFamilyProperties.resize( queueFamilyPropertyCount );
-    d.vkGetPhysicalDeviceQueueFamilyProperties2KHR(
-      m_physicalDevice,
-      &queueFamilyPropertyCount,
-      reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) );
-    VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() );
-    return queueFamilyProperties;
-  }
-
-  template <typename QueueFamilyProperties2Allocator,
-            typename Dispatch,
-            typename B,
-            typename std::enable_if<std::is_same<typename B::value_type, QueueFamilyProperties2>::value, int>::type>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator>
-    PhysicalDevice::getQueueFamilyProperties2KHR( QueueFamilyProperties2Allocator & queueFamilyProperties2Allocator,
-                                                  Dispatch const &                  d ) const
-  {
-    std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator> queueFamilyProperties(
-      queueFamilyProperties2Allocator );
-    uint32_t queueFamilyPropertyCount;
-    d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
-    queueFamilyProperties.resize( queueFamilyPropertyCount );
-    d.vkGetPhysicalDeviceQueueFamilyProperties2KHR(
-      m_physicalDevice,
-      &queueFamilyPropertyCount,
-      reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) );
-    VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() );
-    return queueFamilyProperties;
-  }
-
-  template <typename StructureChain, typename StructureChainAllocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<StructureChain, StructureChainAllocator>
-                                         PhysicalDevice::getQueueFamilyProperties2KHR( Dispatch const & d ) const
-  {
-    uint32_t queueFamilyPropertyCount;
-    d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
-    std::vector<StructureChain, StructureChainAllocator>      returnVector( queueFamilyPropertyCount );
-    std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> queueFamilyProperties( queueFamilyPropertyCount );
-    for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ )
-    {
-      queueFamilyProperties[i].pNext =
-        returnVector[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>().pNext;
-    }
-    d.vkGetPhysicalDeviceQueueFamilyProperties2KHR(
-      m_physicalDevice,
-      &queueFamilyPropertyCount,
-      reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) );
-    VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() );
-    for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ )
-    {
-      returnVector[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>() = queueFamilyProperties[i];
-    }
-    return returnVector;
-  }
-
-  template <typename StructureChain,
-            typename StructureChainAllocator,
-            typename Dispatch,
-            typename B,
-            typename std::enable_if<std::is_same<typename B::value_type, StructureChain>::value, int>::type>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<StructureChain, StructureChainAllocator>
-    PhysicalDevice::getQueueFamilyProperties2KHR( StructureChainAllocator & structureChainAllocator,
-                                                  Dispatch const &          d ) const
-  {
-    uint32_t queueFamilyPropertyCount;
-    d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
-    std::vector<StructureChain, StructureChainAllocator>      returnVector( queueFamilyPropertyCount,
-                                                                       structureChainAllocator );
-    std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> queueFamilyProperties( queueFamilyPropertyCount );
-    for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ )
-    {
-      queueFamilyProperties[i].pNext =
-        returnVector[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>().pNext;
-    }
-    d.vkGetPhysicalDeviceQueueFamilyProperties2KHR(
-      m_physicalDevice,
-      &queueFamilyPropertyCount,
-      reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) );
-    VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() );
-    for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ )
-    {
-      returnVector[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>() = queueFamilyProperties[i];
-    }
-    return returnVector;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#if defined( VK_USE_PLATFORM_SCREEN_QNX )
   template <typename Dispatch>
   VULKAN_HPP_INLINE Bool32 PhysicalDevice::getScreenPresentationSupportQNX(
     uint32_t queueFamilyIndex, struct _screen_window * window, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
@@ -118191,1452 +119982,27 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VK_USE_PLATFORM_SCREEN_QNX*/
 
+  //=== VK_EXT_color_write_enable ===
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setColorWriteEnableEXT( uint32_t                             attachmentCount,
+                                                                const VULKAN_HPP_NAMESPACE::Bool32 * pColorWriteEnables,
+                                                                Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetColorWriteEnableEXT(
+      m_commandBuffer, attachmentCount, reinterpret_cast<const VkBool32 *>( pColorWriteEnables ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void
-    PhysicalDevice::getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format                        format,
-                                                    VULKAN_HPP_NAMESPACE::ImageType                     type,
-                                                    VULKAN_HPP_NAMESPACE::SampleCountFlagBits           samples,
-                                                    VULKAN_HPP_NAMESPACE::ImageUsageFlags               usage,
-                                                    VULKAN_HPP_NAMESPACE::ImageTiling                   tiling,
-                                                    uint32_t *                                          pPropertyCount,
-                                                    VULKAN_HPP_NAMESPACE::SparseImageFormatProperties * pProperties,
-                                                    Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+    CommandBuffer::setColorWriteEnableEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & colorWriteEnables,
+                                           Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
-    d.vkGetPhysicalDeviceSparseImageFormatProperties(
-      m_physicalDevice,
-      static_cast<VkFormat>( format ),
-      static_cast<VkImageType>( type ),
-      static_cast<VkSampleCountFlagBits>( samples ),
-      static_cast<VkImageUsageFlags>( usage ),
-      static_cast<VkImageTiling>( tiling ),
-      pPropertyCount,
-      reinterpret_cast<VkSparseImageFormatProperties *>( pProperties ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename SparseImageFormatPropertiesAllocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties, SparseImageFormatPropertiesAllocator>
-    PhysicalDevice::getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format              format,
-                                                    VULKAN_HPP_NAMESPACE::ImageType           type,
-                                                    VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,
-                                                    VULKAN_HPP_NAMESPACE::ImageUsageFlags     usage,
-                                                    VULKAN_HPP_NAMESPACE::ImageTiling         tiling,
-                                                    Dispatch const &                          d ) const
-  {
-    std::vector<SparseImageFormatProperties, SparseImageFormatPropertiesAllocator> properties;
-    uint32_t                                                                       propertyCount;
-    d.vkGetPhysicalDeviceSparseImageFormatProperties( m_physicalDevice,
-                                                      static_cast<VkFormat>( format ),
-                                                      static_cast<VkImageType>( type ),
-                                                      static_cast<VkSampleCountFlagBits>( samples ),
-                                                      static_cast<VkImageUsageFlags>( usage ),
-                                                      static_cast<VkImageTiling>( tiling ),
-                                                      &propertyCount,
-                                                      nullptr );
-    properties.resize( propertyCount );
-    d.vkGetPhysicalDeviceSparseImageFormatProperties(
-      m_physicalDevice,
-      static_cast<VkFormat>( format ),
-      static_cast<VkImageType>( type ),
-      static_cast<VkSampleCountFlagBits>( samples ),
-      static_cast<VkImageUsageFlags>( usage ),
-      static_cast<VkImageTiling>( tiling ),
-      &propertyCount,
-      reinterpret_cast<VkSparseImageFormatProperties *>( properties.data() ) );
-    VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
-    return properties;
-  }
-
-  template <
-    typename SparseImageFormatPropertiesAllocator,
-    typename Dispatch,
-    typename B,
-    typename std::enable_if<std::is_same<typename B::value_type, SparseImageFormatProperties>::value, int>::type>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties, SparseImageFormatPropertiesAllocator>
-                                         PhysicalDevice::getSparseImageFormatProperties(
-      VULKAN_HPP_NAMESPACE::Format              format,
-      VULKAN_HPP_NAMESPACE::ImageType           type,
-      VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,
-      VULKAN_HPP_NAMESPACE::ImageUsageFlags     usage,
-      VULKAN_HPP_NAMESPACE::ImageTiling         tiling,
-      SparseImageFormatPropertiesAllocator &    sparseImageFormatPropertiesAllocator,
-      Dispatch const &                          d ) const
-  {
-    std::vector<SparseImageFormatProperties, SparseImageFormatPropertiesAllocator> properties(
-      sparseImageFormatPropertiesAllocator );
-    uint32_t propertyCount;
-    d.vkGetPhysicalDeviceSparseImageFormatProperties( m_physicalDevice,
-                                                      static_cast<VkFormat>( format ),
-                                                      static_cast<VkImageType>( type ),
-                                                      static_cast<VkSampleCountFlagBits>( samples ),
-                                                      static_cast<VkImageUsageFlags>( usage ),
-                                                      static_cast<VkImageTiling>( tiling ),
-                                                      &propertyCount,
-                                                      nullptr );
-    properties.resize( propertyCount );
-    d.vkGetPhysicalDeviceSparseImageFormatProperties(
-      m_physicalDevice,
-      static_cast<VkFormat>( format ),
-      static_cast<VkImageType>( type ),
-      static_cast<VkSampleCountFlagBits>( samples ),
-      static_cast<VkImageUsageFlags>( usage ),
-      static_cast<VkImageTiling>( tiling ),
-      &propertyCount,
-      reinterpret_cast<VkSparseImageFormatProperties *>( properties.data() ) );
-    VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
-    return properties;
+    d.vkCmdSetColorWriteEnableEXT(
+      m_commandBuffer, colorWriteEnables.size(), reinterpret_cast<const VkBool32 *>( colorWriteEnables.data() ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getSparseImageFormatProperties2(
-    const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,
-    uint32_t *                                                         pPropertyCount,
-    VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 *               pProperties,
-    Dispatch const &                                                   d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkGetPhysicalDeviceSparseImageFormatProperties2(
-      m_physicalDevice,
-      reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( pFormatInfo ),
-      pPropertyCount,
-      reinterpret_cast<VkSparseImageFormatProperties2 *>( pProperties ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename SparseImageFormatProperties2Allocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD
-    VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
-    PhysicalDevice::getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
-                                                     Dispatch const &                             d ) const
-  {
-    std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> properties;
-    uint32_t                                                                         propertyCount;
-    d.vkGetPhysicalDeviceSparseImageFormatProperties2(
-      m_physicalDevice,
-      reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ),
-      &propertyCount,
-      nullptr );
-    properties.resize( propertyCount );
-    d.vkGetPhysicalDeviceSparseImageFormatProperties2(
-      m_physicalDevice,
-      reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ),
-      &propertyCount,
-      reinterpret_cast<VkSparseImageFormatProperties2 *>( properties.data() ) );
-    VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
-    return properties;
-  }
-
-  template <
-    typename SparseImageFormatProperties2Allocator,
-    typename Dispatch,
-    typename B,
-    typename std::enable_if<std::is_same<typename B::value_type, SparseImageFormatProperties2>::value, int>::type>
-  VULKAN_HPP_NODISCARD
-    VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
-                      PhysicalDevice::getSparseImageFormatProperties2(
-      const PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
-      SparseImageFormatProperties2Allocator &      sparseImageFormatProperties2Allocator,
-      Dispatch const &                             d ) const
-  {
-    std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> properties(
-      sparseImageFormatProperties2Allocator );
-    uint32_t propertyCount;
-    d.vkGetPhysicalDeviceSparseImageFormatProperties2(
-      m_physicalDevice,
-      reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ),
-      &propertyCount,
-      nullptr );
-    properties.resize( propertyCount );
-    d.vkGetPhysicalDeviceSparseImageFormatProperties2(
-      m_physicalDevice,
-      reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ),
-      &propertyCount,
-      reinterpret_cast<VkSparseImageFormatProperties2 *>( properties.data() ) );
-    VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
-    return properties;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getSparseImageFormatProperties2KHR(
-    const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,
-    uint32_t *                                                         pPropertyCount,
-    VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 *               pProperties,
-    Dispatch const &                                                   d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
-      m_physicalDevice,
-      reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( pFormatInfo ),
-      pPropertyCount,
-      reinterpret_cast<VkSparseImageFormatProperties2 *>( pProperties ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename SparseImageFormatProperties2Allocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD
-    VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
-    PhysicalDevice::getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
-                                                        Dispatch const &                             d ) const
-  {
-    std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> properties;
-    uint32_t                                                                         propertyCount;
-    d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
-      m_physicalDevice,
-      reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ),
-      &propertyCount,
-      nullptr );
-    properties.resize( propertyCount );
-    d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
-      m_physicalDevice,
-      reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ),
-      &propertyCount,
-      reinterpret_cast<VkSparseImageFormatProperties2 *>( properties.data() ) );
-    VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
-    return properties;
-  }
-
-  template <
-    typename SparseImageFormatProperties2Allocator,
-    typename Dispatch,
-    typename B,
-    typename std::enable_if<std::is_same<typename B::value_type, SparseImageFormatProperties2>::value, int>::type>
-  VULKAN_HPP_NODISCARD
-    VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
-                      PhysicalDevice::getSparseImageFormatProperties2KHR(
-      const PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
-      SparseImageFormatProperties2Allocator &      sparseImageFormatProperties2Allocator,
-      Dispatch const &                             d ) const
-  {
-    std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> properties(
-      sparseImageFormatProperties2Allocator );
-    uint32_t propertyCount;
-    d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
-      m_physicalDevice,
-      reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ),
-      &propertyCount,
-      nullptr );
-    properties.resize( propertyCount );
-    d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
-      m_physicalDevice,
-      reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ),
-      &propertyCount,
-      reinterpret_cast<VkSparseImageFormatProperties2 *>( properties.data() ) );
-    VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
-    return properties;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV(
-    uint32_t *                                                   pCombinationCount,
-    VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV * pCombinations,
-    Dispatch const &                                             d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
-      m_physicalDevice,
-      pCombinationCount,
-      reinterpret_cast<VkFramebufferMixedSamplesCombinationNV *>( pCombinations ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename FramebufferMixedSamplesCombinationNVAllocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<
-    std::vector<FramebufferMixedSamplesCombinationNV, FramebufferMixedSamplesCombinationNVAllocator>>::type
-    PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV( Dispatch const & d ) const
-  {
-    std::vector<FramebufferMixedSamplesCombinationNV, FramebufferMixedSamplesCombinationNVAllocator> combinations;
-    uint32_t                                                                                         combinationCount;
-    Result                                                                                           result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
-        m_physicalDevice, &combinationCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && combinationCount )
-      {
-        combinations.resize( combinationCount );
-        result = static_cast<Result>( d.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
-          m_physicalDevice,
-          &combinationCount,
-          reinterpret_cast<VkFramebufferMixedSamplesCombinationNV *>( combinations.data() ) ) );
-        VULKAN_HPP_ASSERT( combinationCount <= combinations.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( combinationCount < combinations.size() ) )
-    {
-      combinations.resize( combinationCount );
-    }
-    return createResultValue( result,
-                              combinations,
-                              VULKAN_HPP_NAMESPACE_STRING
-                              "::PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV" );
-  }
-
-  template <typename FramebufferMixedSamplesCombinationNVAllocator,
-            typename Dispatch,
-            typename B,
-            typename std::enable_if<std::is_same<typename B::value_type, FramebufferMixedSamplesCombinationNV>::value,
-                                    int>::type>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<
-    std::vector<FramebufferMixedSamplesCombinationNV, FramebufferMixedSamplesCombinationNVAllocator>>::type
-    PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV(
-      FramebufferMixedSamplesCombinationNVAllocator & framebufferMixedSamplesCombinationNVAllocator,
-      Dispatch const &                                d ) const
-  {
-    std::vector<FramebufferMixedSamplesCombinationNV, FramebufferMixedSamplesCombinationNVAllocator> combinations(
-      framebufferMixedSamplesCombinationNVAllocator );
-    uint32_t combinationCount;
-    Result   result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
-        m_physicalDevice, &combinationCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && combinationCount )
-      {
-        combinations.resize( combinationCount );
-        result = static_cast<Result>( d.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
-          m_physicalDevice,
-          &combinationCount,
-          reinterpret_cast<VkFramebufferMixedSamplesCombinationNV *>( combinations.data() ) ) );
-        VULKAN_HPP_ASSERT( combinationCount <= combinations.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( combinationCount < combinations.size() ) )
-    {
-      combinations.resize( combinationCount );
-    }
-    return createResultValue( result,
-                              combinations,
-                              VULKAN_HPP_NAMESPACE_STRING
-                              "::PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    PhysicalDevice::getSurfaceCapabilities2EXT( VULKAN_HPP_NAMESPACE::SurfaceKHR                surface,
-                                                VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT * pSurfaceCapabilities,
-                                                Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilities2EXT(
-      m_physicalDevice,
-      static_cast<VkSurfaceKHR>( surface ),
-      reinterpret_cast<VkSurfaceCapabilities2EXT *>( pSurfaceCapabilities ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT>::type
-    PhysicalDevice::getSurfaceCapabilities2EXT( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d ) const
-  {
-    VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT surfaceCapabilities;
-    Result result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilities2EXT(
-      m_physicalDevice,
-      static_cast<VkSurfaceKHR>( surface ),
-      reinterpret_cast<VkSurfaceCapabilities2EXT *>( &surfaceCapabilities ) ) );
-    return createResultValue(
-      result, surfaceCapabilities, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilities2EXT" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceCapabilities2KHR(
-    const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
-    VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR *             pSurfaceCapabilities,
-    Dispatch const &                                            d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilities2KHR(
-      m_physicalDevice,
-      reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( pSurfaceInfo ),
-      reinterpret_cast<VkSurfaceCapabilities2KHR *>( pSurfaceCapabilities ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR>::type
-    PhysicalDevice::getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
-                                                Dispatch const &                      d ) const
-  {
-    VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR surfaceCapabilities;
-    Result result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilities2KHR(
-      m_physicalDevice,
-      reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
-      reinterpret_cast<VkSurfaceCapabilities2KHR *>( &surfaceCapabilities ) ) );
-    return createResultValue(
-      result, surfaceCapabilities, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilities2KHR" );
-  }
-
-  template <typename X, typename Y, typename... Z, typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<StructureChain<X, Y, Z...>>::type
-    PhysicalDevice::getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
-                                                Dispatch const &                      d ) const
-  {
-    StructureChain<X, Y, Z...>                      structureChain;
-    VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR & surfaceCapabilities =
-      structureChain.template get<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR>();
-    Result result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilities2KHR(
-      m_physicalDevice,
-      reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
-      reinterpret_cast<VkSurfaceCapabilities2KHR *>( &surfaceCapabilities ) ) );
-    return createResultValue(
-      result, structureChain, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilities2KHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    PhysicalDevice::getSurfaceCapabilitiesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR               surface,
-                                               VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR * pSurfaceCapabilities,
-                                               Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
-      m_physicalDevice,
-      static_cast<VkSurfaceKHR>( surface ),
-      reinterpret_cast<VkSurfaceCapabilitiesKHR *>( pSurfaceCapabilities ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR>::type
-    PhysicalDevice::getSurfaceCapabilitiesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d ) const
-  {
-    VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR surfaceCapabilities;
-    Result result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
-      m_physicalDevice,
-      static_cast<VkSurfaceKHR>( surface ),
-      reinterpret_cast<VkSurfaceCapabilitiesKHR *>( &surfaceCapabilities ) ) );
-    return createResultValue(
-      result, surfaceCapabilities, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilitiesKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    PhysicalDevice::getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
-                                           uint32_t *                                pSurfaceFormatCount,
-                                           VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR * pSurfaceFormats,
-                                           Dispatch const &                          d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormats2KHR(
-      m_physicalDevice,
-      reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( pSurfaceInfo ),
-      pSurfaceFormatCount,
-      reinterpret_cast<VkSurfaceFormat2KHR *>( pSurfaceFormats ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename SurfaceFormat2KHRAllocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
-    typename ResultValueType<std::vector<SurfaceFormat2KHR, SurfaceFormat2KHRAllocator>>::type
-    PhysicalDevice::getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d ) const
-  {
-    std::vector<SurfaceFormat2KHR, SurfaceFormat2KHRAllocator> surfaceFormats;
-    uint32_t                                                   surfaceFormatCount;
-    Result                                                     result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormats2KHR(
-        m_physicalDevice,
-        reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
-        &surfaceFormatCount,
-        nullptr ) );
-      if ( ( result == Result::eSuccess ) && surfaceFormatCount )
-      {
-        surfaceFormats.resize( surfaceFormatCount );
-        result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormats2KHR(
-          m_physicalDevice,
-          reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
-          &surfaceFormatCount,
-          reinterpret_cast<VkSurfaceFormat2KHR *>( surfaceFormats.data() ) ) );
-        VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( surfaceFormatCount < surfaceFormats.size() ) )
-    {
-      surfaceFormats.resize( surfaceFormatCount );
-    }
-    return createResultValue(
-      result, surfaceFormats, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceFormats2KHR" );
-  }
-
-  template <typename SurfaceFormat2KHRAllocator,
-            typename Dispatch,
-            typename B,
-            typename std::enable_if<std::is_same<typename B::value_type, SurfaceFormat2KHR>::value, int>::type>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
-    typename ResultValueType<std::vector<SurfaceFormat2KHR, SurfaceFormat2KHRAllocator>>::type
-    PhysicalDevice::getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
-                                           SurfaceFormat2KHRAllocator &          surfaceFormat2KHRAllocator,
-                                           Dispatch const &                      d ) const
-  {
-    std::vector<SurfaceFormat2KHR, SurfaceFormat2KHRAllocator> surfaceFormats( surfaceFormat2KHRAllocator );
-    uint32_t                                                   surfaceFormatCount;
-    Result                                                     result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormats2KHR(
-        m_physicalDevice,
-        reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
-        &surfaceFormatCount,
-        nullptr ) );
-      if ( ( result == Result::eSuccess ) && surfaceFormatCount )
-      {
-        surfaceFormats.resize( surfaceFormatCount );
-        result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormats2KHR(
-          m_physicalDevice,
-          reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
-          &surfaceFormatCount,
-          reinterpret_cast<VkSurfaceFormat2KHR *>( surfaceFormats.data() ) ) );
-        VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( surfaceFormatCount < surfaceFormats.size() ) )
-    {
-      surfaceFormats.resize( surfaceFormatCount );
-    }
-    return createResultValue(
-      result, surfaceFormats, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceFormats2KHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    PhysicalDevice::getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR         surface,
-                                          uint32_t *                               pSurfaceFormatCount,
-                                          VULKAN_HPP_NAMESPACE::SurfaceFormatKHR * pSurfaceFormats,
-                                          Dispatch const &                         d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice,
-                                              static_cast<VkSurfaceKHR>( surface ),
-                                              pSurfaceFormatCount,
-                                              reinterpret_cast<VkSurfaceFormatKHR *>( pSurfaceFormats ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename SurfaceFormatKHRAllocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
-    typename ResultValueType<std::vector<SurfaceFormatKHR, SurfaceFormatKHRAllocator>>::type
-    PhysicalDevice::getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d ) const
-  {
-    std::vector<SurfaceFormatKHR, SurfaceFormatKHRAllocator> surfaceFormats;
-    uint32_t                                                 surfaceFormatCount;
-    Result                                                   result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormatsKHR(
-        m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &surfaceFormatCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && surfaceFormatCount )
-      {
-        surfaceFormats.resize( surfaceFormatCount );
-        result = static_cast<Result>(
-          d.vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice,
-                                                  static_cast<VkSurfaceKHR>( surface ),
-                                                  &surfaceFormatCount,
-                                                  reinterpret_cast<VkSurfaceFormatKHR *>( surfaceFormats.data() ) ) );
-        VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( surfaceFormatCount < surfaceFormats.size() ) )
-    {
-      surfaceFormats.resize( surfaceFormatCount );
-    }
-    return createResultValue(
-      result, surfaceFormats, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceFormatsKHR" );
-  }
-
-  template <typename SurfaceFormatKHRAllocator,
-            typename Dispatch,
-            typename B,
-            typename std::enable_if<std::is_same<typename B::value_type, SurfaceFormatKHR>::value, int>::type>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
-    typename ResultValueType<std::vector<SurfaceFormatKHR, SurfaceFormatKHRAllocator>>::type
-    PhysicalDevice::getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
-                                          SurfaceFormatKHRAllocator &      surfaceFormatKHRAllocator,
-                                          Dispatch const &                 d ) const
-  {
-    std::vector<SurfaceFormatKHR, SurfaceFormatKHRAllocator> surfaceFormats( surfaceFormatKHRAllocator );
-    uint32_t                                                 surfaceFormatCount;
-    Result                                                   result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormatsKHR(
-        m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &surfaceFormatCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && surfaceFormatCount )
-      {
-        surfaceFormats.resize( surfaceFormatCount );
-        result = static_cast<Result>(
-          d.vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice,
-                                                  static_cast<VkSurfaceKHR>( surface ),
-                                                  &surfaceFormatCount,
-                                                  reinterpret_cast<VkSurfaceFormatKHR *>( surfaceFormats.data() ) ) );
-        VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( surfaceFormatCount < surfaceFormats.size() ) )
-    {
-      surfaceFormats.resize( surfaceFormatCount );
-    }
-    return createResultValue(
-      result, surfaceFormats, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceFormatsKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#if defined( VK_USE_PLATFORM_WIN32_KHR )
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getSurfacePresentModes2EXT(
-    const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
-    uint32_t *                                                  pPresentModeCount,
-    VULKAN_HPP_NAMESPACE::PresentModeKHR *                      pPresentModes,
-    Dispatch const &                                            d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkGetPhysicalDeviceSurfacePresentModes2EXT(
-      m_physicalDevice,
-      reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( pSurfaceInfo ),
-      pPresentModeCount,
-      reinterpret_cast<VkPresentModeKHR *>( pPresentModes ) ) );
-  }
-
-#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename PresentModeKHRAllocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
-    typename ResultValueType<std::vector<PresentModeKHR, PresentModeKHRAllocator>>::type
-    PhysicalDevice::getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
-                                                Dispatch const &                      d ) const
-  {
-    std::vector<PresentModeKHR, PresentModeKHRAllocator> presentModes;
-    uint32_t                                             presentModeCount;
-    Result                                               result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetPhysicalDeviceSurfacePresentModes2EXT(
-        m_physicalDevice,
-        reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
-        &presentModeCount,
-        nullptr ) );
-      if ( ( result == Result::eSuccess ) && presentModeCount )
-      {
-        presentModes.resize( presentModeCount );
-        result = static_cast<Result>( d.vkGetPhysicalDeviceSurfacePresentModes2EXT(
-          m_physicalDevice,
-          reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
-          &presentModeCount,
-          reinterpret_cast<VkPresentModeKHR *>( presentModes.data() ) ) );
-        VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( presentModeCount < presentModes.size() ) )
-    {
-      presentModes.resize( presentModeCount );
-    }
-    return createResultValue(
-      result, presentModes, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfacePresentModes2EXT" );
-  }
-
-  template <typename PresentModeKHRAllocator,
-            typename Dispatch,
-            typename B,
-            typename std::enable_if<std::is_same<typename B::value_type, PresentModeKHR>::value, int>::type>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
-    typename ResultValueType<std::vector<PresentModeKHR, PresentModeKHRAllocator>>::type
-    PhysicalDevice::getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
-                                                PresentModeKHRAllocator &             presentModeKHRAllocator,
-                                                Dispatch const &                      d ) const
-  {
-    std::vector<PresentModeKHR, PresentModeKHRAllocator> presentModes( presentModeKHRAllocator );
-    uint32_t                                             presentModeCount;
-    Result                                               result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetPhysicalDeviceSurfacePresentModes2EXT(
-        m_physicalDevice,
-        reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
-        &presentModeCount,
-        nullptr ) );
-      if ( ( result == Result::eSuccess ) && presentModeCount )
-      {
-        presentModes.resize( presentModeCount );
-        result = static_cast<Result>( d.vkGetPhysicalDeviceSurfacePresentModes2EXT(
-          m_physicalDevice,
-          reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
-          &presentModeCount,
-          reinterpret_cast<VkPresentModeKHR *>( presentModes.data() ) ) );
-        VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( presentModeCount < presentModes.size() ) )
-    {
-      presentModes.resize( presentModeCount );
-    }
-    return createResultValue(
-      result, presentModes, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfacePresentModes2EXT" );
-  }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_USE_PLATFORM_WIN32_KHR*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    PhysicalDevice::getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR       surface,
-                                               uint32_t *                             pPresentModeCount,
-                                               VULKAN_HPP_NAMESPACE::PresentModeKHR * pPresentModes,
-                                               Dispatch const &                       d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice,
-                                                   static_cast<VkSurfaceKHR>( surface ),
-                                                   pPresentModeCount,
-                                                   reinterpret_cast<VkPresentModeKHR *>( pPresentModes ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename PresentModeKHRAllocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
-    typename ResultValueType<std::vector<PresentModeKHR, PresentModeKHRAllocator>>::type
-    PhysicalDevice::getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d ) const
-  {
-    std::vector<PresentModeKHR, PresentModeKHRAllocator> presentModes;
-    uint32_t                                             presentModeCount;
-    Result                                               result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetPhysicalDeviceSurfacePresentModesKHR(
-        m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &presentModeCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && presentModeCount )
-      {
-        presentModes.resize( presentModeCount );
-        result = static_cast<Result>(
-          d.vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice,
-                                                       static_cast<VkSurfaceKHR>( surface ),
-                                                       &presentModeCount,
-                                                       reinterpret_cast<VkPresentModeKHR *>( presentModes.data() ) ) );
-        VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( presentModeCount < presentModes.size() ) )
-    {
-      presentModes.resize( presentModeCount );
-    }
-    return createResultValue(
-      result, presentModes, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfacePresentModesKHR" );
-  }
-
-  template <typename PresentModeKHRAllocator,
-            typename Dispatch,
-            typename B,
-            typename std::enable_if<std::is_same<typename B::value_type, PresentModeKHR>::value, int>::type>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
-    typename ResultValueType<std::vector<PresentModeKHR, PresentModeKHRAllocator>>::type
-    PhysicalDevice::getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
-                                               PresentModeKHRAllocator &        presentModeKHRAllocator,
-                                               Dispatch const &                 d ) const
-  {
-    std::vector<PresentModeKHR, PresentModeKHRAllocator> presentModes( presentModeKHRAllocator );
-    uint32_t                                             presentModeCount;
-    Result                                               result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetPhysicalDeviceSurfacePresentModesKHR(
-        m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &presentModeCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && presentModeCount )
-      {
-        presentModes.resize( presentModeCount );
-        result = static_cast<Result>(
-          d.vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice,
-                                                       static_cast<VkSurfaceKHR>( surface ),
-                                                       &presentModeCount,
-                                                       reinterpret_cast<VkPresentModeKHR *>( presentModes.data() ) ) );
-        VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( presentModeCount < presentModes.size() ) )
-    {
-      presentModes.resize( presentModeCount );
-    }
-    return createResultValue(
-      result, presentModes, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfacePresentModesKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    PhysicalDevice::getSurfaceSupportKHR( uint32_t                         queueFamilyIndex,
-                                          VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
-                                          VULKAN_HPP_NAMESPACE::Bool32 *   pSupported,
-                                          Dispatch const &                 d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkGetPhysicalDeviceSurfaceSupportKHR( m_physicalDevice,
-                                                                        queueFamilyIndex,
-                                                                        static_cast<VkSurfaceKHR>( surface ),
-                                                                        reinterpret_cast<VkBool32 *>( pSupported ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::Bool32>::type
-                                          PhysicalDevice::getSurfaceSupportKHR( uint32_t                         queueFamilyIndex,
-                                          VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
-                                          Dispatch const &                 d ) const
-  {
-    VULKAN_HPP_NAMESPACE::Bool32 supported;
-    Result                       result =
-      static_cast<Result>( d.vkGetPhysicalDeviceSurfaceSupportKHR( m_physicalDevice,
-                                                                   queueFamilyIndex,
-                                                                   static_cast<VkSurfaceKHR>( surface ),
-                                                                   reinterpret_cast<VkBool32 *>( &supported ) ) );
-    return createResultValue( result, supported, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceSupportKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    PhysicalDevice::getToolPropertiesEXT( uint32_t *                                              pToolCount,
-                                          VULKAN_HPP_NAMESPACE::PhysicalDeviceToolPropertiesEXT * pToolProperties,
-                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkGetPhysicalDeviceToolPropertiesEXT(
-      m_physicalDevice, pToolCount, reinterpret_cast<VkPhysicalDeviceToolPropertiesEXT *>( pToolProperties ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename PhysicalDeviceToolPropertiesEXTAllocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<
-    std::vector<PhysicalDeviceToolPropertiesEXT, PhysicalDeviceToolPropertiesEXTAllocator>>::type
-    PhysicalDevice::getToolPropertiesEXT( Dispatch const & d ) const
-  {
-    std::vector<PhysicalDeviceToolPropertiesEXT, PhysicalDeviceToolPropertiesEXTAllocator> toolProperties;
-    uint32_t                                                                               toolCount;
-    Result                                                                                 result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetPhysicalDeviceToolPropertiesEXT( m_physicalDevice, &toolCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && toolCount )
-      {
-        toolProperties.resize( toolCount );
-        result = static_cast<Result>( d.vkGetPhysicalDeviceToolPropertiesEXT(
-          m_physicalDevice,
-          &toolCount,
-          reinterpret_cast<VkPhysicalDeviceToolPropertiesEXT *>( toolProperties.data() ) ) );
-        VULKAN_HPP_ASSERT( toolCount <= toolProperties.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( toolCount < toolProperties.size() ) )
-    {
-      toolProperties.resize( toolCount );
-    }
-    return createResultValue(
-      result, toolProperties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getToolPropertiesEXT" );
-  }
-
-  template <
-    typename PhysicalDeviceToolPropertiesEXTAllocator,
-    typename Dispatch,
-    typename B,
-    typename std::enable_if<std::is_same<typename B::value_type, PhysicalDeviceToolPropertiesEXT>::value, int>::type>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<
-    std::vector<PhysicalDeviceToolPropertiesEXT, PhysicalDeviceToolPropertiesEXTAllocator>>::type
-    PhysicalDevice::getToolPropertiesEXT(
-      PhysicalDeviceToolPropertiesEXTAllocator & physicalDeviceToolPropertiesEXTAllocator, Dispatch const & d ) const
-  {
-    std::vector<PhysicalDeviceToolPropertiesEXT, PhysicalDeviceToolPropertiesEXTAllocator> toolProperties(
-      physicalDeviceToolPropertiesEXTAllocator );
-    uint32_t toolCount;
-    Result   result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetPhysicalDeviceToolPropertiesEXT( m_physicalDevice, &toolCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && toolCount )
-      {
-        toolProperties.resize( toolCount );
-        result = static_cast<Result>( d.vkGetPhysicalDeviceToolPropertiesEXT(
-          m_physicalDevice,
-          &toolCount,
-          reinterpret_cast<VkPhysicalDeviceToolPropertiesEXT *>( toolProperties.data() ) ) );
-        VULKAN_HPP_ASSERT( toolCount <= toolProperties.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( toolCount < toolProperties.size() ) )
-    {
-      toolProperties.resize( toolCount );
-    }
-    return createResultValue(
-      result, toolProperties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getToolPropertiesEXT" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#if defined( VK_ENABLE_BETA_EXTENSIONS )
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    PhysicalDevice::getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileKHR * pVideoProfile,
-                                             VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR *  pCapabilities,
-                                             Dispatch const &                              d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkGetPhysicalDeviceVideoCapabilitiesKHR( m_physicalDevice,
-                                                 reinterpret_cast<const VkVideoProfileKHR *>( pVideoProfile ),
-                                                 reinterpret_cast<VkVideoCapabilitiesKHR *>( pCapabilities ) ) );
-  }
-
-#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR>::type
-    PhysicalDevice::getVideoCapabilitiesKHR( const VideoProfileKHR & videoProfile, Dispatch const & d ) const
-  {
-    VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR capabilities;
-    Result                                     result = static_cast<Result>(
-      d.vkGetPhysicalDeviceVideoCapabilitiesKHR( m_physicalDevice,
-                                                 reinterpret_cast<const VkVideoProfileKHR *>( &videoProfile ),
-                                                 reinterpret_cast<VkVideoCapabilitiesKHR *>( &capabilities ) ) );
-    return createResultValue(
-      result, capabilities, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoCapabilitiesKHR" );
-  }
-
-  template <typename X, typename Y, typename... Z, typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<StructureChain<X, Y, Z...>>::type
-    PhysicalDevice::getVideoCapabilitiesKHR( const VideoProfileKHR & videoProfile, Dispatch const & d ) const
-  {
-    StructureChain<X, Y, Z...>                   structureChain;
-    VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR & capabilities =
-      structureChain.template get<VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR>();
-    Result result = static_cast<Result>(
-      d.vkGetPhysicalDeviceVideoCapabilitiesKHR( m_physicalDevice,
-                                                 reinterpret_cast<const VkVideoProfileKHR *>( &videoProfile ),
-                                                 reinterpret_cast<VkVideoCapabilitiesKHR *>( &capabilities ) ) );
-    return createResultValue(
-      result, structureChain, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoCapabilitiesKHR" );
-  }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_ENABLE_BETA_EXTENSIONS*/
-
-#if defined( VK_ENABLE_BETA_EXTENSIONS )
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getVideoFormatPropertiesKHR(
-    const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR * pVideoFormatInfo,
-    uint32_t *                                                     pVideoFormatPropertyCount,
-    VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR *               pVideoFormatProperties,
-    Dispatch const &                                               d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkGetPhysicalDeviceVideoFormatPropertiesKHR(
-      m_physicalDevice,
-      reinterpret_cast<const VkPhysicalDeviceVideoFormatInfoKHR *>( pVideoFormatInfo ),
-      pVideoFormatPropertyCount,
-      reinterpret_cast<VkVideoFormatPropertiesKHR *>( pVideoFormatProperties ) ) );
-  }
-
-#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename VideoFormatPropertiesKHRAllocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
-    typename ResultValueType<std::vector<VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator>>::type
-    PhysicalDevice::getVideoFormatPropertiesKHR( const PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo,
-                                                 Dispatch const &                         d ) const
-  {
-    std::vector<VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator> videoFormatProperties;
-    uint32_t                                                                 videoFormatPropertyCount;
-    Result                                                                   result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetPhysicalDeviceVideoFormatPropertiesKHR(
-        m_physicalDevice,
-        reinterpret_cast<const VkPhysicalDeviceVideoFormatInfoKHR *>( &videoFormatInfo ),
-        &videoFormatPropertyCount,
-        nullptr ) );
-      if ( ( result == Result::eSuccess ) && videoFormatPropertyCount )
-      {
-        videoFormatProperties.resize( videoFormatPropertyCount );
-        result = static_cast<Result>( d.vkGetPhysicalDeviceVideoFormatPropertiesKHR(
-          m_physicalDevice,
-          reinterpret_cast<const VkPhysicalDeviceVideoFormatInfoKHR *>( &videoFormatInfo ),
-          &videoFormatPropertyCount,
-          reinterpret_cast<VkVideoFormatPropertiesKHR *>( videoFormatProperties.data() ) ) );
-        VULKAN_HPP_ASSERT( videoFormatPropertyCount <= videoFormatProperties.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( videoFormatPropertyCount < videoFormatProperties.size() ) )
-    {
-      videoFormatProperties.resize( videoFormatPropertyCount );
-    }
-    return createResultValue(
-      result, videoFormatProperties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoFormatPropertiesKHR" );
-  }
-
-  template <typename VideoFormatPropertiesKHRAllocator,
-            typename Dispatch,
-            typename B,
-            typename std::enable_if<std::is_same<typename B::value_type, VideoFormatPropertiesKHR>::value, int>::type>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
-    typename ResultValueType<std::vector<VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator>>::type
-    PhysicalDevice::getVideoFormatPropertiesKHR( const PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo,
-                                                 VideoFormatPropertiesKHRAllocator & videoFormatPropertiesKHRAllocator,
-                                                 Dispatch const &                    d ) const
-  {
-    std::vector<VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator> videoFormatProperties(
-      videoFormatPropertiesKHRAllocator );
-    uint32_t videoFormatPropertyCount;
-    Result   result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetPhysicalDeviceVideoFormatPropertiesKHR(
-        m_physicalDevice,
-        reinterpret_cast<const VkPhysicalDeviceVideoFormatInfoKHR *>( &videoFormatInfo ),
-        &videoFormatPropertyCount,
-        nullptr ) );
-      if ( ( result == Result::eSuccess ) && videoFormatPropertyCount )
-      {
-        videoFormatProperties.resize( videoFormatPropertyCount );
-        result = static_cast<Result>( d.vkGetPhysicalDeviceVideoFormatPropertiesKHR(
-          m_physicalDevice,
-          reinterpret_cast<const VkPhysicalDeviceVideoFormatInfoKHR *>( &videoFormatInfo ),
-          &videoFormatPropertyCount,
-          reinterpret_cast<VkVideoFormatPropertiesKHR *>( videoFormatProperties.data() ) ) );
-        VULKAN_HPP_ASSERT( videoFormatPropertyCount <= videoFormatProperties.size() );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( ( result == Result::eSuccess ) && ( videoFormatPropertyCount < videoFormatProperties.size() ) )
-    {
-      videoFormatProperties.resize( videoFormatPropertyCount );
-    }
-    return createResultValue(
-      result, videoFormatProperties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoFormatPropertiesKHR" );
-  }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_ENABLE_BETA_EXTENSIONS*/
-
-#if defined( VK_USE_PLATFORM_WAYLAND_KHR )
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE Bool32 PhysicalDevice::getWaylandPresentationSupportKHR(
-    uint32_t queueFamilyIndex, struct wl_display * display, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Bool32>(
-      d.vkGetPhysicalDeviceWaylandPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, display ) );
-  }
-
-#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE Bool32 PhysicalDevice::getWaylandPresentationSupportKHR(
-    uint32_t queueFamilyIndex, struct wl_display & display, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return d.vkGetPhysicalDeviceWaylandPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &display );
-  }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_USE_PLATFORM_WAYLAND_KHR*/
-
-#if defined( VK_USE_PLATFORM_WIN32_KHR )
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE Bool32 PhysicalDevice::getWin32PresentationSupportKHR(
-    uint32_t queueFamilyIndex, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Bool32>(
-      d.vkGetPhysicalDeviceWin32PresentationSupportKHR( m_physicalDevice, queueFamilyIndex ) );
-  }
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#if defined( VK_USE_PLATFORM_XCB_KHR )
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXcbPresentationSupportKHR( uint32_t           queueFamilyIndex,
-                                                                         xcb_connection_t * connection,
-                                                                         xcb_visualid_t     visual_id,
-                                                                         Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Bool32>(
-      d.vkGetPhysicalDeviceXcbPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, connection, visual_id ) );
-  }
-
-#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXcbPresentationSupportKHR( uint32_t           queueFamilyIndex,
-                                                                         xcb_connection_t & connection,
-                                                                         xcb_visualid_t     visual_id,
-                                                                         Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return d.vkGetPhysicalDeviceXcbPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &connection, visual_id );
-  }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_USE_PLATFORM_XCB_KHR*/
-
-#if defined( VK_USE_PLATFORM_XLIB_KHR )
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXlibPresentationSupportKHR( uint32_t         queueFamilyIndex,
-                                                                          Display *        dpy,
-                                                                          VisualID         visualID,
-                                                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Bool32>(
-      d.vkGetPhysicalDeviceXlibPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, dpy, visualID ) );
-  }
-
-#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXlibPresentationSupportKHR( uint32_t         queueFamilyIndex,
-                                                                          Display &        dpy,
-                                                                          VisualID         visualID,
-                                                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return d.vkGetPhysicalDeviceXlibPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &dpy, visualID );
-  }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif   /*VK_USE_PLATFORM_XLIB_KHR*/
-
-#if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    PhysicalDevice::getRandROutputDisplayEXT( Display *                          dpy,
-                                              RROutput                           rrOutput,
-                                              VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplay,
-                                              Dispatch const &                   d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkGetRandROutputDisplayEXT( m_physicalDevice, dpy, rrOutput, reinterpret_cast<VkDisplayKHR *>( pDisplay ) ) );
-  }
-
-#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type
-    PhysicalDevice::getRandROutputDisplayEXT( Display & dpy, RROutput rrOutput, Dispatch const & d ) const
-  {
-    VULKAN_HPP_NAMESPACE::DisplayKHR display;
-    Result                           result = static_cast<Result>(
-      d.vkGetRandROutputDisplayEXT( m_physicalDevice, &dpy, rrOutput, reinterpret_cast<VkDisplayKHR *>( &display ) ) );
-    return createResultValue(
-      result, display, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getRandROutputDisplayEXT" );
-  }
-
-#    ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type
-    PhysicalDevice::getRandROutputDisplayEXTUnique( Display & dpy, RROutput rrOutput, Dispatch const & d ) const
-  {
-    VULKAN_HPP_NAMESPACE::DisplayKHR display;
-    Result                           result = static_cast<Result>(
-      d.vkGetRandROutputDisplayEXT( m_physicalDevice, &dpy, rrOutput, reinterpret_cast<VkDisplayKHR *>( &display ) ) );
-    ObjectRelease<PhysicalDevice, Dispatch> deleter( *this, d );
-    return createResultValue<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>(
-      result, display, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getRandROutputDisplayEXTUnique", deleter );
-  }
-#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif     /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
-
-#if defined( VK_USE_PLATFORM_WIN32_KHR )
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    PhysicalDevice::getWinrtDisplayNV( uint32_t                           deviceRelativeId,
-                                       VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplay,
-                                       Dispatch const &                   d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkGetWinrtDisplayNV( m_physicalDevice, deviceRelativeId, reinterpret_cast<VkDisplayKHR *>( pDisplay ) ) );
-  }
-
-#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type
-    PhysicalDevice::getWinrtDisplayNV( uint32_t deviceRelativeId, Dispatch const & d ) const
-  {
-    VULKAN_HPP_NAMESPACE::DisplayKHR display;
-    Result                           result = static_cast<Result>(
-      d.vkGetWinrtDisplayNV( m_physicalDevice, deviceRelativeId, reinterpret_cast<VkDisplayKHR *>( &display ) ) );
-    return createResultValue( result, display, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getWinrtDisplayNV" );
-  }
-
-#    ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type
-    PhysicalDevice::getWinrtDisplayNVUnique( uint32_t deviceRelativeId, Dispatch const & d ) const
-  {
-    VULKAN_HPP_NAMESPACE::DisplayKHR display;
-    Result                           result = static_cast<Result>(
-      d.vkGetWinrtDisplayNV( m_physicalDevice, deviceRelativeId, reinterpret_cast<VkDisplayKHR *>( &display ) ) );
-    ObjectRelease<PhysicalDevice, Dispatch> deleter( *this, d );
-    return createResultValue<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>(
-      result, display, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getWinrtDisplayNVUnique", deleter );
-  }
-#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif     /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::releaseDisplayEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display,
-                                                              Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkReleaseDisplayEXT( m_physicalDevice, static_cast<VkDisplayKHR>( display ) ) );
-  }
-#else
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<void>::type
-    PhysicalDevice::releaseDisplayEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d ) const
-  {
-    Result result =
-      static_cast<Result>( d.vkReleaseDisplayEXT( m_physicalDevice, static_cast<VkDisplayKHR>( display ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::releaseDisplayEXT" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Queue::getCheckpointData2NV( uint32_t *                                pCheckpointDataCount,
-                                                      VULKAN_HPP_NAMESPACE::CheckpointData2NV * pCheckpointData,
-                                                      Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkGetQueueCheckpointData2NV(
-      m_queue, pCheckpointDataCount, reinterpret_cast<VkCheckpointData2NV *>( pCheckpointData ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename CheckpointData2NVAllocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<CheckpointData2NV, CheckpointData2NVAllocator>
-                                         Queue::getCheckpointData2NV( Dispatch const & d ) const
-  {
-    std::vector<CheckpointData2NV, CheckpointData2NVAllocator> checkpointData;
-    uint32_t                                                   checkpointDataCount;
-    d.vkGetQueueCheckpointData2NV( m_queue, &checkpointDataCount, nullptr );
-    checkpointData.resize( checkpointDataCount );
-    d.vkGetQueueCheckpointData2NV(
-      m_queue, &checkpointDataCount, reinterpret_cast<VkCheckpointData2NV *>( checkpointData.data() ) );
-    VULKAN_HPP_ASSERT( checkpointDataCount <= checkpointData.size() );
-    return checkpointData;
-  }
-
-  template <typename CheckpointData2NVAllocator,
-            typename Dispatch,
-            typename B,
-            typename std::enable_if<std::is_same<typename B::value_type, CheckpointData2NV>::value, int>::type>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<CheckpointData2NV, CheckpointData2NVAllocator>
-    Queue::getCheckpointData2NV( CheckpointData2NVAllocator & checkpointData2NVAllocator, Dispatch const & d ) const
-  {
-    std::vector<CheckpointData2NV, CheckpointData2NVAllocator> checkpointData( checkpointData2NVAllocator );
-    uint32_t                                                   checkpointDataCount;
-    d.vkGetQueueCheckpointData2NV( m_queue, &checkpointDataCount, nullptr );
-    checkpointData.resize( checkpointDataCount );
-    d.vkGetQueueCheckpointData2NV(
-      m_queue, &checkpointDataCount, reinterpret_cast<VkCheckpointData2NV *>( checkpointData.data() ) );
-    VULKAN_HPP_ASSERT( checkpointDataCount <= checkpointData.size() );
-    return checkpointData;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Queue::getCheckpointDataNV( uint32_t *                               pCheckpointDataCount,
-                                                     VULKAN_HPP_NAMESPACE::CheckpointDataNV * pCheckpointData,
-                                                     Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkGetQueueCheckpointDataNV(
-      m_queue, pCheckpointDataCount, reinterpret_cast<VkCheckpointDataNV *>( pCheckpointData ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename CheckpointDataNVAllocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<CheckpointDataNV, CheckpointDataNVAllocator>
-                                         Queue::getCheckpointDataNV( Dispatch const & d ) const
-  {
-    std::vector<CheckpointDataNV, CheckpointDataNVAllocator> checkpointData;
-    uint32_t                                                 checkpointDataCount;
-    d.vkGetQueueCheckpointDataNV( m_queue, &checkpointDataCount, nullptr );
-    checkpointData.resize( checkpointDataCount );
-    d.vkGetQueueCheckpointDataNV(
-      m_queue, &checkpointDataCount, reinterpret_cast<VkCheckpointDataNV *>( checkpointData.data() ) );
-    VULKAN_HPP_ASSERT( checkpointDataCount <= checkpointData.size() );
-    return checkpointData;
-  }
-
-  template <typename CheckpointDataNVAllocator,
-            typename Dispatch,
-            typename B,
-            typename std::enable_if<std::is_same<typename B::value_type, CheckpointDataNV>::value, int>::type>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<CheckpointDataNV, CheckpointDataNVAllocator>
-    Queue::getCheckpointDataNV( CheckpointDataNVAllocator & checkpointDataNVAllocator, Dispatch const & d ) const
-  {
-    std::vector<CheckpointDataNV, CheckpointDataNVAllocator> checkpointData( checkpointDataNVAllocator );
-    uint32_t                                                 checkpointDataCount;
-    d.vkGetQueueCheckpointDataNV( m_queue, &checkpointDataCount, nullptr );
-    checkpointData.resize( checkpointDataCount );
-    d.vkGetQueueCheckpointDataNV(
-      m_queue, &checkpointDataCount, reinterpret_cast<VkCheckpointDataNV *>( checkpointData.data() ) );
-    VULKAN_HPP_ASSERT( checkpointDataCount <= checkpointData.size() );
-    return checkpointData;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Queue::beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo,
-                                                         Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkQueueBeginDebugUtilsLabelEXT( m_queue, reinterpret_cast<const VkDebugUtilsLabelEXT *>( pLabelInfo ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Queue::beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo,
-                                                         Dispatch const &           d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkQueueBeginDebugUtilsLabelEXT( m_queue, reinterpret_cast<const VkDebugUtilsLabelEXT *>( &labelInfo ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Queue::bindSparse( uint32_t                                     bindInfoCount,
-                       const VULKAN_HPP_NAMESPACE::BindSparseInfo * pBindInfo,
-                       VULKAN_HPP_NAMESPACE::Fence                  fence,
-                       Dispatch const &                             d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkQueueBindSparse( m_queue,
-                                                     bindInfoCount,
-                                                     reinterpret_cast<const VkBindSparseInfo *>( pBindInfo ),
-                                                     static_cast<VkFence>( fence ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
-    Queue::bindSparse( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindSparseInfo> const & bindInfo,
-                       VULKAN_HPP_NAMESPACE::Fence                                    fence,
-                       Dispatch const &                                               d ) const
-  {
-    Result result =
-      static_cast<Result>( d.vkQueueBindSparse( m_queue,
-                                                bindInfo.size(),
-                                                reinterpret_cast<const VkBindSparseInfo *>( bindInfo.data() ),
-                                                static_cast<VkFence>( fence ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::bindSparse" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Queue::endDebugUtilsLabelEXT( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkQueueEndDebugUtilsLabelEXT( m_queue );
-  }
-
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Queue::insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo,
-                                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkQueueInsertDebugUtilsLabelEXT( m_queue, reinterpret_cast<const VkDebugUtilsLabelEXT *>( pLabelInfo ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Queue::insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo,
-                                                          Dispatch const &           d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkQueueInsertDebugUtilsLabelEXT( m_queue, reinterpret_cast<const VkDebugUtilsLabelEXT *>( &labelInfo ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Queue::presentKHR(
-    const VULKAN_HPP_NAMESPACE::PresentInfoKHR * pPresentInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>(
-      d.vkQueuePresentKHR( m_queue, reinterpret_cast<const VkPresentInfoKHR *>( pPresentInfo ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Queue::presentKHR( const PresentInfoKHR & presentInfo,
-                                                                   Dispatch const &       d ) const
-  {
-    Result result =
-      static_cast<Result>( d.vkQueuePresentKHR( m_queue, reinterpret_cast<const VkPresentInfoKHR *>( &presentInfo ) ) );
-    return createResultValue(
-      result,
-      VULKAN_HPP_NAMESPACE_STRING "::Queue::presentKHR",
-      { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR } );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Queue::setPerformanceConfigurationINTEL(
-    VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkQueueSetPerformanceConfigurationINTEL(
-      m_queue, static_cast<VkPerformanceConfigurationINTEL>( configuration ) ) );
-  }
-#else
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
-    Queue::setPerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,
-                                             Dispatch const & d ) const
-  {
-    Result result = static_cast<Result>( d.vkQueueSetPerformanceConfigurationINTEL(
-      m_queue, static_cast<VkPerformanceConfigurationINTEL>( configuration ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::setPerformanceConfigurationINTEL" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Queue::submit( uint32_t                                 submitCount,
-                                                               const VULKAN_HPP_NAMESPACE::SubmitInfo * pSubmits,
-                                                               VULKAN_HPP_NAMESPACE::Fence              fence,
-                                                               Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkQueueSubmit(
-      m_queue, submitCount, reinterpret_cast<const VkSubmitInfo *>( pSubmits ), static_cast<VkFence>( fence ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
-    Queue::submit( ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo> const & submits,
-                   VULKAN_HPP_NAMESPACE::Fence                                fence,
-                   Dispatch const &                                           d ) const
-  {
-    Result result = static_cast<Result>( d.vkQueueSubmit( m_queue,
-                                                          submits.size(),
-                                                          reinterpret_cast<const VkSubmitInfo *>( submits.data() ),
-                                                          static_cast<VkFence>( fence ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::submit" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
-    Queue::submit2KHR( uint32_t                                     submitCount,
-                       const VULKAN_HPP_NAMESPACE::SubmitInfo2KHR * pSubmits,
-                       VULKAN_HPP_NAMESPACE::Fence                  fence,
-                       Dispatch const &                             d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkQueueSubmit2KHR(
-      m_queue, submitCount, reinterpret_cast<const VkSubmitInfo2KHR *>( pSubmits ), static_cast<VkFence>( fence ) ) );
-  }
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
-    Queue::submit2KHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo2KHR> const & submits,
-                       VULKAN_HPP_NAMESPACE::Fence                                    fence,
-                       Dispatch const &                                               d ) const
-  {
-    Result result =
-      static_cast<Result>( d.vkQueueSubmit2KHR( m_queue,
-                                                submits.size(),
-                                                reinterpret_cast<const VkSubmitInfo2KHR *>( submits.data() ),
-                                                static_cast<VkFence>( fence ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::submit2KHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Queue::waitIdle( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    return static_cast<Result>( d.vkQueueWaitIdle( m_queue ) );
-  }
-#else
-  template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
-    Queue::waitIdle( Dispatch const & d ) const
-  {
-    Result result = static_cast<Result>( d.vkQueueWaitIdle( m_queue ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::waitIdle" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
   template <>
   struct StructExtends<AndroidHardwareBufferFormatPropertiesANDROID, AndroidHardwareBufferPropertiesANDROID>
diff --git a/vulkan/vulkan_raii.hpp b/vulkan/vulkan_raii.hpp
index 2db2de7..026880f 100644
--- a/vulkan/vulkan_raii.hpp
+++ b/vulkan/vulkan_raii.hpp
@@ -1685,11 +1685,15 @@ namespace VULKAN_HPP_NAMESPACE
         return *this;
       }
 
+      //=== VK_VERSION_1_0 ===
+
       VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties> enumerateInstanceExtensionProperties(
         Optional<const std::string> layerName VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const;
 
       VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::LayerProperties> enumerateInstanceLayerProperties() const;
 
+      //=== VK_VERSION_1_1 ===
+
       VULKAN_HPP_NODISCARD uint32_t enumerateInstanceVersion() const;
 
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ContextDispatcher const * getDispatcher() const
@@ -1770,6 +1774,17 @@ namespace VULKAN_HPP_NAMESPACE
         return *this;
       }
 
+      //=== VK_VERSION_1_0 ===
+
+      VULKAN_HPP_NODISCARD PFN_vkVoidFunction getProcAddr( const std::string & name ) const VULKAN_HPP_NOEXCEPT;
+
+      //=== VK_VERSION_1_1 ===
+
+      VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>
+                           enumeratePhysicalDeviceGroups() const;
+
+      //=== VK_EXT_debug_report ===
+
       void debugReportMessageEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT      flags,
                                   VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType_,
                                   uint64_t                                       object,
@@ -1778,13 +1793,12 @@ namespace VULKAN_HPP_NAMESPACE
                                   const std::string &                            layerPrefix,
                                   const std::string &                            message ) const VULKAN_HPP_NOEXCEPT;
 
-      VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>
-                           enumeratePhysicalDeviceGroups() const;
+      //=== VK_KHR_device_group_creation ===
 
       VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>
                            enumeratePhysicalDeviceGroupsKHR() const;
 
-      VULKAN_HPP_NODISCARD PFN_vkVoidFunction getProcAddr( const std::string & name ) const VULKAN_HPP_NOEXCEPT;
+      //=== VK_EXT_debug_utils ===
 
       void
         submitDebugUtilsMessageEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
@@ -1845,52 +1859,161 @@ namespace VULKAN_HPP_NAMESPACE
         return *this;
       }
 
-#  if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
-      void acquireXlibDisplayEXT( Display & dpy, VULKAN_HPP_NAMESPACE::DisplayKHR display ) const;
-#  endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
+      //=== VK_VERSION_1_0 ===
+
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures getFeatures() const VULKAN_HPP_NOEXCEPT;
+
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties
+                           getFormatProperties( VULKAN_HPP_NAMESPACE::Format format ) const VULKAN_HPP_NOEXCEPT;
+
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ImageFormatProperties getImageFormatProperties(
+        VULKAN_HPP_NAMESPACE::Format                 format,
+        VULKAN_HPP_NAMESPACE::ImageType              type,
+        VULKAN_HPP_NAMESPACE::ImageTiling            tiling,
+        VULKAN_HPP_NAMESPACE::ImageUsageFlags        usage,
+        VULKAN_HPP_NAMESPACE::ImageCreateFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const;
+
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties getProperties() const VULKAN_HPP_NOEXCEPT;
+
+      VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties>
+                           getQueueFamilyProperties() const VULKAN_HPP_NOEXCEPT;
+
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties
+                           getMemoryProperties() const VULKAN_HPP_NOEXCEPT;
 
       VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties> enumerateDeviceExtensionProperties(
         Optional<const std::string> layerName VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const;
 
       VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::LayerProperties> enumerateDeviceLayerProperties() const;
 
-      VULKAN_HPP_NODISCARD std::pair<std::vector<PerformanceCounterKHR>, std::vector<PerformanceCounterDescriptionKHR>>
-                           enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex ) const;
+      VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties>
+                           getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format              format,
+                                                           VULKAN_HPP_NAMESPACE::ImageType           type,
+                                                           VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,
+                                                           VULKAN_HPP_NAMESPACE::ImageUsageFlags     usage,
+                                                           VULKAN_HPP_NAMESPACE::ImageTiling         tiling ) const VULKAN_HPP_NOEXCEPT;
 
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR
-                           getDisplayPlaneCapabilities2KHR( const DisplayPlaneInfo2KHR & displayPlaneInfo ) const;
+      //=== VK_VERSION_1_1 ===
 
-      VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::TimeDomainEXT> getCalibrateableTimeDomainsEXT() const;
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 getFeatures2() const VULKAN_HPP_NOEXCEPT;
 
-      VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV>
-                           getCooperativeMatrixPropertiesNV() const;
+      template <typename X, typename Y, typename... Z>
+      VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getFeatures2() const VULKAN_HPP_NOEXCEPT;
 
-#  if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Bool32
-        getDirectFBPresentationSupportEXT( uint32_t queueFamilyIndex, IDirectFB & dfb ) const VULKAN_HPP_NOEXCEPT;
-#  endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 getProperties2() const VULKAN_HPP_NOEXCEPT;
 
-      VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR>
-                           getDisplayPlaneProperties2KHR() const;
+      template <typename X, typename Y, typename... Z>
+      VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getProperties2() const VULKAN_HPP_NOEXCEPT;
 
-      VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR>
-                           getDisplayPlanePropertiesKHR() const;
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties2
+                           getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format ) const VULKAN_HPP_NOEXCEPT;
 
-      VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR> getDisplayProperties2KHR() const;
+      template <typename X, typename Y, typename... Z>
+      VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
+                           getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format ) const VULKAN_HPP_NOEXCEPT;
 
-      VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR> getDisplayPropertiesKHR() const;
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ImageFormatProperties2
+                           getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const;
+
+      template <typename X, typename Y, typename... Z>
+      VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
+                           getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const;
+
+      VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>
+                           getQueueFamilyProperties2() const VULKAN_HPP_NOEXCEPT;
+
+      template <typename StructureChain>
+      VULKAN_HPP_NODISCARD std::vector<StructureChain> getQueueFamilyProperties2() const;
+
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2
+                           getMemoryProperties2() const VULKAN_HPP_NOEXCEPT;
+
+      template <typename X, typename Y, typename... Z>
+      VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getMemoryProperties2() const VULKAN_HPP_NOEXCEPT;
+
+      VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>
+        getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo ) const
+        VULKAN_HPP_NOEXCEPT;
 
       VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalBufferProperties getExternalBufferProperties(
         const PhysicalDeviceExternalBufferInfo & externalBufferInfo ) const VULKAN_HPP_NOEXCEPT;
 
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalBufferProperties getExternalBufferPropertiesKHR(
-        const PhysicalDeviceExternalBufferInfo & externalBufferInfo ) const VULKAN_HPP_NOEXCEPT;
-
       VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalFenceProperties getExternalFenceProperties(
         const PhysicalDeviceExternalFenceInfo & externalFenceInfo ) const VULKAN_HPP_NOEXCEPT;
 
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalFenceProperties getExternalFencePropertiesKHR(
-        const PhysicalDeviceExternalFenceInfo & externalFenceInfo ) const VULKAN_HPP_NOEXCEPT;
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties getExternalSemaphoreProperties(
+        const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo ) const VULKAN_HPP_NOEXCEPT;
+
+      //=== VK_KHR_surface ===
+
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Bool32
+        getSurfaceSupportKHR( uint32_t queueFamilyIndex, VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const;
+
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR
+                           getSurfaceCapabilitiesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const;
+
+      VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR>
+                           getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const;
+
+      VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR>
+                           getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const;
+
+      //=== VK_KHR_swapchain ===
+
+      VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::Rect2D>
+                           getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const;
+
+      //=== VK_KHR_display ===
+
+      VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR> getDisplayPropertiesKHR() const;
+
+      VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR>
+                           getDisplayPlanePropertiesKHR() const;
+
+#  if defined( VK_USE_PLATFORM_XLIB_KHR )
+      //=== VK_KHR_xlib_surface ===
+
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Bool32 getXlibPresentationSupportKHR(
+        uint32_t queueFamilyIndex, Display & dpy, VisualID visualID ) const VULKAN_HPP_NOEXCEPT;
+#  endif /*VK_USE_PLATFORM_XLIB_KHR*/
+
+#  if defined( VK_USE_PLATFORM_XCB_KHR )
+      //=== VK_KHR_xcb_surface ===
+
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Bool32 getXcbPresentationSupportKHR(
+        uint32_t queueFamilyIndex, xcb_connection_t & connection, xcb_visualid_t visual_id ) const VULKAN_HPP_NOEXCEPT;
+#  endif /*VK_USE_PLATFORM_XCB_KHR*/
+
+#  if defined( VK_USE_PLATFORM_WAYLAND_KHR )
+      //=== VK_KHR_wayland_surface ===
+
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Bool32
+                           getWaylandPresentationSupportKHR( uint32_t            queueFamilyIndex,
+                                                             struct wl_display & display ) const VULKAN_HPP_NOEXCEPT;
+#  endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
+
+#  if defined( VK_USE_PLATFORM_WIN32_KHR )
+      //=== VK_KHR_win32_surface ===
+
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Bool32
+                           getWin32PresentationSupportKHR( uint32_t queueFamilyIndex ) const VULKAN_HPP_NOEXCEPT;
+#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+#  if defined( VK_ENABLE_BETA_EXTENSIONS )
+      //=== VK_KHR_video_queue ===
+
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR
+                           getVideoCapabilitiesKHR( const VideoProfileKHR & videoProfile ) const;
+
+      template <typename X, typename Y, typename... Z>
+      VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
+                           getVideoCapabilitiesKHR( const VideoProfileKHR & videoProfile ) const;
+
+      VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR>
+        getVideoFormatPropertiesKHR( const PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo ) const;
+#  endif /*VK_ENABLE_BETA_EXTENSIONS*/
+
+      //=== VK_NV_external_memory_capabilities ===
 
       VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV getExternalImageFormatPropertiesNV(
         VULKAN_HPP_NAMESPACE::Format                 format,
@@ -1901,110 +2024,32 @@ namespace VULKAN_HPP_NAMESPACE
         VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV externalHandleType
           VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const;
 
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties getExternalSemaphoreProperties(
-        const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo ) const VULKAN_HPP_NOEXCEPT;
-
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties getExternalSemaphorePropertiesKHR(
-        const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo ) const VULKAN_HPP_NOEXCEPT;
-
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures getFeatures() const VULKAN_HPP_NOEXCEPT;
-
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 getFeatures2() const VULKAN_HPP_NOEXCEPT;
-
-      template <typename X, typename Y, typename... Z>
-      VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getFeatures2() const VULKAN_HPP_NOEXCEPT;
+      //=== VK_KHR_get_physical_device_properties2 ===
 
       VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 getFeatures2KHR() const VULKAN_HPP_NOEXCEPT;
 
       template <typename X, typename Y, typename... Z>
       VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getFeatures2KHR() const VULKAN_HPP_NOEXCEPT;
 
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties
-                           getFormatProperties( VULKAN_HPP_NAMESPACE::Format format ) const VULKAN_HPP_NOEXCEPT;
-
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties2
-                           getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format ) const VULKAN_HPP_NOEXCEPT;
-
-      template <typename X, typename Y, typename... Z>
-      VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
-                           getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format ) const VULKAN_HPP_NOEXCEPT;
-
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties2
-                           getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format ) const VULKAN_HPP_NOEXCEPT;
-
-      template <typename X, typename Y, typename... Z>
-      VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
-                           getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format ) const VULKAN_HPP_NOEXCEPT;
-
-      VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR>
-                           getFragmentShadingRatesKHR() const;
-
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ImageFormatProperties getImageFormatProperties(
-        VULKAN_HPP_NAMESPACE::Format                 format,
-        VULKAN_HPP_NAMESPACE::ImageType              type,
-        VULKAN_HPP_NAMESPACE::ImageTiling            tiling,
-        VULKAN_HPP_NAMESPACE::ImageUsageFlags        usage,
-        VULKAN_HPP_NAMESPACE::ImageCreateFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const;
-
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ImageFormatProperties2
-                           getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const;
-
-      template <typename X, typename Y, typename... Z>
-      VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
-                           getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const;
-
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ImageFormatProperties2
-                           getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const;
-
-      template <typename X, typename Y, typename... Z>
-      VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
-                           getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const;
-
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties
-                           getMemoryProperties() const VULKAN_HPP_NOEXCEPT;
-
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2
-                           getMemoryProperties2() const VULKAN_HPP_NOEXCEPT;
-
-      template <typename X, typename Y, typename... Z>
-      VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getMemoryProperties2() const VULKAN_HPP_NOEXCEPT;
-
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2
-                           getMemoryProperties2KHR() const VULKAN_HPP_NOEXCEPT;
-
-      template <typename X, typename Y, typename... Z>
-      VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getMemoryProperties2KHR() const VULKAN_HPP_NOEXCEPT;
-
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT
-        getMultisamplePropertiesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples ) const VULKAN_HPP_NOEXCEPT;
-
-      VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::Rect2D>
-                           getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const;
-
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties getProperties() const VULKAN_HPP_NOEXCEPT;
-
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 getProperties2() const VULKAN_HPP_NOEXCEPT;
-
-      template <typename X, typename Y, typename... Z>
-      VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getProperties2() const VULKAN_HPP_NOEXCEPT;
-
       VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2
                            getProperties2KHR() const VULKAN_HPP_NOEXCEPT;
 
       template <typename X, typename Y, typename... Z>
       VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getProperties2KHR() const VULKAN_HPP_NOEXCEPT;
 
-      VULKAN_HPP_NODISCARD uint32_t getQueueFamilyPerformanceQueryPassesKHR(
-        const QueryPoolPerformanceCreateInfoKHR & performanceQueryCreateInfo ) const VULKAN_HPP_NOEXCEPT;
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties2
+                           getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format ) const VULKAN_HPP_NOEXCEPT;
 
-      VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties>
-                           getQueueFamilyProperties() const VULKAN_HPP_NOEXCEPT;
+      template <typename X, typename Y, typename... Z>
+      VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
+                           getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format ) const VULKAN_HPP_NOEXCEPT;
 
-      VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>
-                           getQueueFamilyProperties2() const VULKAN_HPP_NOEXCEPT;
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ImageFormatProperties2
+                           getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const;
 
-      template <typename StructureChain>
-      VULKAN_HPP_NODISCARD std::vector<StructureChain> getQueueFamilyProperties2() const;
+      template <typename X, typename Y, typename... Z>
+      VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
+                           getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const;
 
       VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>
                            getQueueFamilyProperties2KHR() const VULKAN_HPP_NOEXCEPT;
@@ -2012,33 +2057,52 @@ namespace VULKAN_HPP_NAMESPACE
       template <typename StructureChain>
       VULKAN_HPP_NODISCARD std::vector<StructureChain> getQueueFamilyProperties2KHR() const;
 
-#  if defined( VK_USE_PLATFORM_SCREEN_QNX )
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Bool32
-                           getScreenPresentationSupportQNX( uint32_t                queueFamilyIndex,
-                                                            struct _screen_window & window ) const VULKAN_HPP_NOEXCEPT;
-#  endif /*VK_USE_PLATFORM_SCREEN_QNX*/
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2
+                           getMemoryProperties2KHR() const VULKAN_HPP_NOEXCEPT;
 
-      VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties>
-                           getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format              format,
-                                                           VULKAN_HPP_NAMESPACE::ImageType           type,
-                                                           VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,
-                                                           VULKAN_HPP_NAMESPACE::ImageUsageFlags     usage,
-                                                           VULKAN_HPP_NAMESPACE::ImageTiling         tiling ) const VULKAN_HPP_NOEXCEPT;
-
-      VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>
-        getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo ) const
-        VULKAN_HPP_NOEXCEPT;
+      template <typename X, typename Y, typename... Z>
+      VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getMemoryProperties2KHR() const VULKAN_HPP_NOEXCEPT;
 
       VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>
         getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo ) const
         VULKAN_HPP_NOEXCEPT;
 
-      VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV>
-                           getSupportedFramebufferMixedSamplesCombinationsNV() const;
+      //=== VK_KHR_external_memory_capabilities ===
+
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalBufferProperties getExternalBufferPropertiesKHR(
+        const PhysicalDeviceExternalBufferInfo & externalBufferInfo ) const VULKAN_HPP_NOEXCEPT;
+
+      //=== VK_KHR_external_semaphore_capabilities ===
+
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties getExternalSemaphorePropertiesKHR(
+        const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo ) const VULKAN_HPP_NOEXCEPT;
+
+#  if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
+      //=== VK_EXT_acquire_xlib_display ===
+
+      void acquireXlibDisplayEXT( Display & dpy, VULKAN_HPP_NAMESPACE::DisplayKHR display ) const;
+#  endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
+
+      //=== VK_EXT_display_surface_counter ===
 
       VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT
                            getSurfaceCapabilities2EXT( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const;
 
+      //=== VK_KHR_external_fence_capabilities ===
+
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalFenceProperties getExternalFencePropertiesKHR(
+        const PhysicalDeviceExternalFenceInfo & externalFenceInfo ) const VULKAN_HPP_NOEXCEPT;
+
+      //=== VK_KHR_performance_query ===
+
+      VULKAN_HPP_NODISCARD std::pair<std::vector<PerformanceCounterKHR>, std::vector<PerformanceCounterDescriptionKHR>>
+                           enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex ) const;
+
+      VULKAN_HPP_NODISCARD uint32_t getQueueFamilyPerformanceQueryPassesKHR(
+        const QueryPoolPerformanceCreateInfoKHR & performanceQueryCreateInfo ) const VULKAN_HPP_NOEXCEPT;
+
+      //=== VK_KHR_get_surface_capabilities2 ===
+
       VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR
                            getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const;
 
@@ -2046,65 +2110,69 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
                            getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const;
 
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR
-                           getSurfaceCapabilitiesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const;
-
       VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR>
                            getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const;
 
-      VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR>
-                           getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const;
+      //=== VK_KHR_get_display_properties2 ===
 
-#  if defined( VK_USE_PLATFORM_WIN32_KHR )
-      VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR>
-                           getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const;
-#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
+      VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR> getDisplayProperties2KHR() const;
 
-      VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR>
-                           getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const;
+      VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR>
+                           getDisplayPlaneProperties2KHR() const;
 
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Bool32
-        getSurfaceSupportKHR( uint32_t queueFamilyIndex, VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const;
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR
+                           getDisplayPlaneCapabilities2KHR( const DisplayPlaneInfo2KHR & displayPlaneInfo ) const;
+
+      //=== VK_EXT_sample_locations ===
+
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT
+        getMultisamplePropertiesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples ) const VULKAN_HPP_NOEXCEPT;
+
+      //=== VK_EXT_calibrated_timestamps ===
+
+      VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::TimeDomainEXT> getCalibrateableTimeDomainsEXT() const;
+
+      //=== VK_KHR_fragment_shading_rate ===
+
+      VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR>
+                           getFragmentShadingRatesKHR() const;
+
+      //=== VK_EXT_tooling_info ===
 
       VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolPropertiesEXT>
                            getToolPropertiesEXT() const;
 
-#  if defined( VK_ENABLE_BETA_EXTENSIONS )
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR
-                           getVideoCapabilitiesKHR( const VideoProfileKHR & videoProfile ) const;
-#  endif /*VK_ENABLE_BETA_EXTENSIONS*/
+      //=== VK_NV_cooperative_matrix ===
 
-#  if defined( VK_ENABLE_BETA_EXTENSIONS )
-      template <typename X, typename Y, typename... Z>
-      VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
-                           getVideoCapabilitiesKHR( const VideoProfileKHR & videoProfile ) const;
-#  endif /*VK_ENABLE_BETA_EXTENSIONS*/
+      VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV>
+                           getCooperativeMatrixPropertiesNV() const;
 
-#  if defined( VK_ENABLE_BETA_EXTENSIONS )
-      VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR>
-        getVideoFormatPropertiesKHR( const PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo ) const;
-#  endif /*VK_ENABLE_BETA_EXTENSIONS*/
+      //=== VK_NV_coverage_reduction_mode ===
 
-#  if defined( VK_USE_PLATFORM_WAYLAND_KHR )
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Bool32
-                           getWaylandPresentationSupportKHR( uint32_t            queueFamilyIndex,
-                                                             struct wl_display & display ) const VULKAN_HPP_NOEXCEPT;
-#  endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
+      VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV>
+                           getSupportedFramebufferMixedSamplesCombinationsNV() const;
 
 #  if defined( VK_USE_PLATFORM_WIN32_KHR )
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Bool32
-                           getWin32PresentationSupportKHR( uint32_t queueFamilyIndex ) const VULKAN_HPP_NOEXCEPT;
+      //=== VK_EXT_full_screen_exclusive ===
+
+      VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR>
+                           getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const;
 #  endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
-#  if defined( VK_USE_PLATFORM_XCB_KHR )
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Bool32 getXcbPresentationSupportKHR(
-        uint32_t queueFamilyIndex, xcb_connection_t & connection, xcb_visualid_t visual_id ) const VULKAN_HPP_NOEXCEPT;
-#  endif /*VK_USE_PLATFORM_XCB_KHR*/
+#  if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
+      //=== VK_EXT_directfb_surface ===
 
-#  if defined( VK_USE_PLATFORM_XLIB_KHR )
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Bool32 getXlibPresentationSupportKHR(
-        uint32_t queueFamilyIndex, Display & dpy, VisualID visualID ) const VULKAN_HPP_NOEXCEPT;
-#  endif /*VK_USE_PLATFORM_XLIB_KHR*/
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Bool32
+        getDirectFBPresentationSupportEXT( uint32_t queueFamilyIndex, IDirectFB & dfb ) const VULKAN_HPP_NOEXCEPT;
+#  endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
+
+#  if defined( VK_USE_PLATFORM_SCREEN_QNX )
+      //=== VK_QNX_screen_surface ===
+
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Bool32
+                           getScreenPresentationSupportQNX( uint32_t                queueFamilyIndex,
+                                                            struct _screen_window & window ) const VULKAN_HPP_NOEXCEPT;
+#  endif /*VK_USE_PLATFORM_SCREEN_QNX*/
 
       VULKAN_HPP_NAMESPACE::PhysicalDevice const & operator*() const VULKAN_HPP_NOEXCEPT
       {
@@ -2233,21 +2301,218 @@ namespace VULKAN_HPP_NAMESPACE
         return *this;
       }
 
-      VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::Result, uint32_t>
-                           acquireNextImage2KHR( const AcquireNextImageInfoKHR & acquireInfo ) const;
+      //=== VK_VERSION_1_0 ===
 
-      void acquireProfilingLockKHR( const AcquireProfilingLockInfoKHR & info ) const;
+      VULKAN_HPP_NODISCARD PFN_vkVoidFunction getProcAddr( const std::string & name ) const VULKAN_HPP_NOEXCEPT;
 
-      void bindAccelerationStructureMemoryNV(
-        ArrayProxy<const VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV> const & bindInfos ) const;
+      void waitIdle() const;
+
+      void
+        flushMappedMemoryRanges( ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges ) const;
+
+      void invalidateMappedMemoryRanges(
+        ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges ) const;
+
+      void resetFences( ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences ) const;
+
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result
+                           waitForFences( ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences,
+                                          VULKAN_HPP_NAMESPACE::Bool32                          waitAll,
+                                          uint64_t                                              timeout ) const;
+
+      void updateDescriptorSets(
+        ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites,
+        ArrayProxy<const VULKAN_HPP_NAMESPACE::CopyDescriptorSet> const &  descriptorCopies ) const VULKAN_HPP_NOEXCEPT;
+
+      //=== VK_VERSION_1_1 ===
 
       void bindBufferMemory2( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos ) const;
 
-      void bindBufferMemory2KHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos ) const;
-
       void bindImageMemory2( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos ) const;
 
-      void bindImageMemory2KHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos ) const;
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags getGroupPeerMemoryFeatures(
+        uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex ) const VULKAN_HPP_NOEXCEPT;
+
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2
+        getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT;
+
+      template <typename X, typename Y, typename... Z>
+      VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
+        getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT;
+
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2
+        getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT;
+
+      template <typename X, typename Y, typename... Z>
+      VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
+        getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT;
+
+      VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>
+        getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT;
+
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport
+        getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT;
+
+      template <typename X, typename Y, typename... Z>
+      VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
+        getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT;
+
+      //=== VK_VERSION_1_2 ===
+
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitSemaphores( const SemaphoreWaitInfo & waitInfo,
+                                                                        uint64_t                  timeout ) const;
+
+      void signalSemaphore( const SemaphoreSignalInfo & signalInfo ) const;
+
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceAddress
+                           getBufferAddress( const BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT;
+
+      VULKAN_HPP_NODISCARD uint64_t
+        getBufferOpaqueCaptureAddress( const BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT;
+
+      VULKAN_HPP_NODISCARD uint64_t
+        getMemoryOpaqueCaptureAddress( const DeviceMemoryOpaqueCaptureAddressInfo & info ) const VULKAN_HPP_NOEXCEPT;
+
+      //=== VK_KHR_swapchain ===
+
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR
+                           getGroupPresentCapabilitiesKHR() const;
+
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR
+                           getGroupSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const;
+
+      VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::Result, uint32_t>
+                           acquireNextImage2KHR( const AcquireNextImageInfoKHR & acquireInfo ) const;
+
+      //=== VK_EXT_debug_marker ===
+
+      void debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT & tagInfo ) const;
+
+      void debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT & nameInfo ) const;
+
+      //=== VK_NVX_image_view_handle ===
+
+      VULKAN_HPP_NODISCARD uint32_t
+        getImageViewHandleNVX( const ImageViewHandleInfoNVX & info ) const VULKAN_HPP_NOEXCEPT;
+
+      //=== VK_KHR_device_group ===
+
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags getGroupPeerMemoryFeaturesKHR(
+        uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex ) const VULKAN_HPP_NOEXCEPT;
+
+#  if defined( VK_USE_PLATFORM_WIN32_KHR )
+      //=== VK_KHR_external_memory_win32 ===
+
+      VULKAN_HPP_NODISCARD HANDLE
+        getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR & getWin32HandleInfo ) const;
+
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR
+        getMemoryWin32HandlePropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
+                                           HANDLE                                                 handle ) const;
+#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+      //=== VK_KHR_external_memory_fd ===
+
+      VULKAN_HPP_NODISCARD int getMemoryFdKHR( const MemoryGetFdInfoKHR & getFdInfo ) const;
+
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR
+        getMemoryFdPropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, int fd ) const;
+
+#  if defined( VK_USE_PLATFORM_WIN32_KHR )
+      //=== VK_KHR_external_semaphore_win32 ===
+
+      void
+        importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo ) const;
+
+      VULKAN_HPP_NODISCARD HANDLE
+        getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo ) const;
+#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+      //=== VK_KHR_external_semaphore_fd ===
+
+      void importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo ) const;
+
+      VULKAN_HPP_NODISCARD int getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR & getFdInfo ) const;
+
+      //=== VK_KHR_descriptor_update_template ===
+
+      void destroyDescriptorUpdateTemplateKHR(
+        VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
+        Optional<const AllocationCallbacks> allocator
+          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+      //=== VK_EXT_display_control ===
+
+      void displayPowerControlEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display,
+                                   const DisplayPowerInfoEXT &      displayPowerInfo ) const;
+
+      //=== VK_EXT_hdr_metadata ===
+
+      void setHdrMetadataEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainKHR> const &   swapchains,
+                              ArrayProxy<const VULKAN_HPP_NAMESPACE::HdrMetadataEXT> const & metadata ) const
+        VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
+
+#  if defined( VK_USE_PLATFORM_WIN32_KHR )
+      //=== VK_KHR_external_fence_win32 ===
+
+      void importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo ) const;
+
+      VULKAN_HPP_NODISCARD HANDLE getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR & getWin32HandleInfo ) const;
+#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+      //=== VK_KHR_external_fence_fd ===
+
+      void importFenceFdKHR( const ImportFenceFdInfoKHR & importFenceFdInfo ) const;
+
+      VULKAN_HPP_NODISCARD int getFenceFdKHR( const FenceGetFdInfoKHR & getFdInfo ) const;
+
+      //=== VK_KHR_performance_query ===
+
+      void acquireProfilingLockKHR( const AcquireProfilingLockInfoKHR & info ) const;
+
+      void releaseProfilingLockKHR() const VULKAN_HPP_NOEXCEPT;
+
+      //=== VK_EXT_debug_utils ===
+
+      void setDebugUtilsObjectNameEXT( const DebugUtilsObjectNameInfoEXT & nameInfo ) const;
+
+      void setDebugUtilsObjectTagEXT( const DebugUtilsObjectTagInfoEXT & tagInfo ) const;
+
+#  if defined( VK_USE_PLATFORM_ANDROID_KHR )
+      //=== VK_ANDROID_external_memory_android_hardware_buffer ===
+
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID
+                           getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer ) const;
+
+      template <typename X, typename Y, typename... Z>
+      VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
+                           getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer ) const;
+
+      VULKAN_HPP_NODISCARD struct AHardwareBuffer *
+        getMemoryAndroidHardwareBufferANDROID( const MemoryGetAndroidHardwareBufferInfoANDROID & info ) const;
+#  endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+
+      //=== VK_KHR_get_memory_requirements2 ===
+
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2
+        getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT;
+
+      template <typename X, typename Y, typename... Z>
+      VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
+        getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT;
+
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2
+        getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT;
+
+      template <typename X, typename Y, typename... Z>
+      VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
+        getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT;
+
+      VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>
+                           getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info ) const
+        VULKAN_HPP_NOEXCEPT;
+
+      //=== VK_KHR_acceleration_structure ===
 
       VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result buildAccelerationStructuresKHR(
         VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                                deferredOperation,
@@ -2267,294 +2532,6 @@ namespace VULKAN_HPP_NAMESPACE
         copyMemoryToAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR       deferredOperation,
                                               const CopyMemoryToAccelerationStructureInfoKHR & info ) const;
 
-      void debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT & nameInfo ) const;
-
-      void debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT & tagInfo ) const;
-
-      void destroyDescriptorUpdateTemplateKHR(
-        VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
-        Optional<const AllocationCallbacks> allocator
-          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-      void destroySamplerYcbcrConversionKHR(
-        VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
-        Optional<const AllocationCallbacks> allocator
-          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-
-      void waitIdle() const;
-
-      void displayPowerControlEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display,
-                                   const DisplayPowerInfoEXT &      displayPowerInfo ) const;
-
-      void
-        flushMappedMemoryRanges( ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges ) const;
-
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR
-        getAccelerationStructureBuildSizesKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType,
-                                               const AccelerationStructureBuildGeometryInfoKHR &       buildInfo,
-                                               ArrayProxy<const uint32_t> const & maxPrimitiveCounts
-                                                 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const
-        VULKAN_HPP_NOEXCEPT;
-
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceAddress getAccelerationStructureAddressKHR(
-        const AccelerationStructureDeviceAddressInfoKHR & info ) const VULKAN_HPP_NOEXCEPT;
-
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR getAccelerationStructureMemoryRequirementsNV(
-        const AccelerationStructureMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT;
-
-      template <typename X, typename Y, typename... Z>
-      VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getAccelerationStructureMemoryRequirementsNV(
-        const AccelerationStructureMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT;
-
-#  if defined( VK_USE_PLATFORM_ANDROID_KHR )
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID
-                           getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer ) const;
-#  endif /*VK_USE_PLATFORM_ANDROID_KHR*/
-
-#  if defined( VK_USE_PLATFORM_ANDROID_KHR )
-      template <typename X, typename Y, typename... Z>
-      VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
-                           getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer ) const;
-#  endif /*VK_USE_PLATFORM_ANDROID_KHR*/
-
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceAddress
-                           getBufferAddress( const BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT;
-
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceAddress
-                           getBufferAddressEXT( const BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT;
-
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceAddress
-                           getBufferAddressKHR( const BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT;
-
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2
-        getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT;
-
-      template <typename X, typename Y, typename... Z>
-      VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
-        getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT;
-
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2
-        getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT;
-
-      template <typename X, typename Y, typename... Z>
-      VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
-        getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT;
-
-      VULKAN_HPP_NODISCARD uint64_t
-        getBufferOpaqueCaptureAddress( const BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT;
-
-      VULKAN_HPP_NODISCARD uint64_t
-        getBufferOpaqueCaptureAddressKHR( const BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT;
-
-      VULKAN_HPP_NODISCARD std::pair<std::vector<uint64_t>, uint64_t> getCalibratedTimestampsEXT(
-        ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT> const & timestampInfos ) const;
-
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport
-        getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT;
-
-      template <typename X, typename Y, typename... Z>
-      VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
-        getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT;
-
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport
-        getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT;
-
-      template <typename X, typename Y, typename... Z>
-      VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
-        getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT;
-
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR
-        getAccelerationStructureCompatibilityKHR( const AccelerationStructureVersionInfoKHR & versionInfo ) const
-        VULKAN_HPP_NOEXCEPT;
-
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags getGroupPeerMemoryFeatures(
-        uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex ) const VULKAN_HPP_NOEXCEPT;
-
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags getGroupPeerMemoryFeaturesKHR(
-        uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex ) const VULKAN_HPP_NOEXCEPT;
-
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR
-                           getGroupPresentCapabilitiesKHR() const;
-
-#  if defined( VK_USE_PLATFORM_WIN32_KHR )
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR
-                           getGroupSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const;
-#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR
-                           getGroupSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const;
-
-      VULKAN_HPP_NODISCARD uint64_t
-        getMemoryOpaqueCaptureAddress( const DeviceMemoryOpaqueCaptureAddressInfo & info ) const VULKAN_HPP_NOEXCEPT;
-
-      VULKAN_HPP_NODISCARD uint64_t
-        getMemoryOpaqueCaptureAddressKHR( const DeviceMemoryOpaqueCaptureAddressInfo & info ) const VULKAN_HPP_NOEXCEPT;
-
-      VULKAN_HPP_NODISCARD PFN_vkVoidFunction getProcAddr( const std::string & name ) const VULKAN_HPP_NOEXCEPT;
-
-      VULKAN_HPP_NODISCARD int getFenceFdKHR( const FenceGetFdInfoKHR & getFdInfo ) const;
-
-#  if defined( VK_USE_PLATFORM_WIN32_KHR )
-      VULKAN_HPP_NODISCARD HANDLE getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR & getWin32HandleInfo ) const;
-#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getGeneratedCommandsMemoryRequirementsNV(
-        const GeneratedCommandsMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT;
-
-      template <typename X, typename Y, typename... Z>
-      VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getGeneratedCommandsMemoryRequirementsNV(
-        const GeneratedCommandsMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT;
-
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2
-        getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT;
-
-      template <typename X, typename Y, typename... Z>
-      VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
-        getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT;
-
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2
-        getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT;
-
-      template <typename X, typename Y, typename... Z>
-      VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
-        getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT;
-
-      VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>
-        getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT;
-
-      VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>
-                           getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info ) const
-        VULKAN_HPP_NOEXCEPT;
-
-      VULKAN_HPP_NODISCARD uint32_t
-        getImageViewHandleNVX( const ImageViewHandleInfoNVX & info ) const VULKAN_HPP_NOEXCEPT;
-
-#  if defined( VK_USE_PLATFORM_ANDROID_KHR )
-      VULKAN_HPP_NODISCARD struct AHardwareBuffer *
-        getMemoryAndroidHardwareBufferANDROID( const MemoryGetAndroidHardwareBufferInfoANDROID & info ) const;
-#  endif /*VK_USE_PLATFORM_ANDROID_KHR*/
-
-      VULKAN_HPP_NODISCARD int getMemoryFdKHR( const MemoryGetFdInfoKHR & getFdInfo ) const;
-
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR
-        getMemoryFdPropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, int fd ) const;
-
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT
-        getMemoryHostPointerPropertiesEXT( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
-                                           const void *                                           pHostPointer ) const;
-
-#  if defined( VK_USE_PLATFORM_WIN32_KHR )
-      VULKAN_HPP_NODISCARD HANDLE
-        getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR & getWin32HandleInfo ) const;
-#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#  if defined( VK_USE_PLATFORM_WIN32_KHR )
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR
-        getMemoryWin32HandlePropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
-                                           HANDLE                                                 handle ) const;
-#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#  if defined( VK_USE_PLATFORM_FUCHSIA )
-      VULKAN_HPP_NODISCARD zx_handle_t
-        getMemoryZirconHandleFUCHSIA( const MemoryGetZirconHandleInfoFUCHSIA & getZirconHandleInfo ) const;
-#  endif /*VK_USE_PLATFORM_FUCHSIA*/
-
-#  if defined( VK_USE_PLATFORM_FUCHSIA )
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA
-        getMemoryZirconHandlePropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
-                                                zx_handle_t zirconHandle ) const;
-#  endif /*VK_USE_PLATFORM_FUCHSIA*/
-
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PerformanceValueINTEL
-        getPerformanceParameterINTEL( VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL parameter ) const;
-
-      VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR>
-        getPipelineExecutableInternalRepresentationsKHR( const PipelineExecutableInfoKHR & executableInfo ) const;
-
-      VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR>
-                           getPipelineExecutablePropertiesKHR( const PipelineInfoKHR & pipelineInfo ) const;
-
-      VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR>
-                           getPipelineExecutableStatisticsKHR( const PipelineExecutableInfoKHR & executableInfo ) const;
-
-      VULKAN_HPP_NODISCARD uint64_t
-        getPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType         objectType_,
-                           uint64_t                                 objectHandle,
-                           VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot ) const VULKAN_HPP_NOEXCEPT;
-
-      VULKAN_HPP_NODISCARD int getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR & getFdInfo ) const;
-
-#  if defined( VK_USE_PLATFORM_WIN32_KHR )
-      VULKAN_HPP_NODISCARD HANDLE
-        getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo ) const;
-#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#  if defined( VK_USE_PLATFORM_FUCHSIA )
-      VULKAN_HPP_NODISCARD zx_handle_t
-        getSemaphoreZirconHandleFUCHSIA( const SemaphoreGetZirconHandleInfoFUCHSIA & getZirconHandleInfo ) const;
-#  endif /*VK_USE_PLATFORM_FUCHSIA*/
-
-      void importFenceFdKHR( const ImportFenceFdInfoKHR & importFenceFdInfo ) const;
-
-#  if defined( VK_USE_PLATFORM_WIN32_KHR )
-      void importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo ) const;
-#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-      void importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo ) const;
-
-#  if defined( VK_USE_PLATFORM_WIN32_KHR )
-      void
-        importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo ) const;
-#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#  if defined( VK_USE_PLATFORM_FUCHSIA )
-      void importSemaphoreZirconHandleFUCHSIA(
-        const ImportSemaphoreZirconHandleInfoFUCHSIA & importSemaphoreZirconHandleInfo ) const;
-#  endif /*VK_USE_PLATFORM_FUCHSIA*/
-
-      void initializePerformanceApiINTEL( const InitializePerformanceApiInfoINTEL & initializeInfo ) const;
-
-      void invalidateMappedMemoryRanges(
-        ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges ) const;
-
-      void releaseProfilingLockKHR() const VULKAN_HPP_NOEXCEPT;
-
-      void resetFences( ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences ) const;
-
-      void setDebugUtilsObjectNameEXT( const DebugUtilsObjectNameInfoEXT & nameInfo ) const;
-
-      void setDebugUtilsObjectTagEXT( const DebugUtilsObjectTagInfoEXT & tagInfo ) const;
-
-      void setHdrMetadataEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainKHR> const &   swapchains,
-                              ArrayProxy<const VULKAN_HPP_NAMESPACE::HdrMetadataEXT> const & metadata ) const
-        VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
-
-      void setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType         objectType_,
-                              uint64_t                                 objectHandle,
-                              VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot,
-                              uint64_t                                 data ) const;
-
-      void signalSemaphore( const SemaphoreSignalInfo & signalInfo ) const;
-
-      void signalSemaphoreKHR( const SemaphoreSignalInfo & signalInfo ) const;
-
-      void uninitializePerformanceApiINTEL() const VULKAN_HPP_NOEXCEPT;
-
-      void updateDescriptorSets(
-        ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites,
-        ArrayProxy<const VULKAN_HPP_NAMESPACE::CopyDescriptorSet> const &  descriptorCopies ) const VULKAN_HPP_NOEXCEPT;
-
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result
-                           waitForFences( ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences,
-                                          VULKAN_HPP_NAMESPACE::Bool32                          waitAll,
-                                          uint64_t                                              timeout ) const;
-
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitSemaphores( const SemaphoreWaitInfo & waitInfo,
-                                                                        uint64_t                  timeout ) const;
-
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitSemaphoresKHR( const SemaphoreWaitInfo & waitInfo,
-                                                                           uint64_t                  timeout ) const;
-
       template <typename T>
       VULKAN_HPP_NODISCARD std::vector<T> writeAccelerationStructuresPropertiesKHR(
         ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
@@ -2568,6 +2545,157 @@ namespace VULKAN_HPP_NAMESPACE
         VULKAN_HPP_NAMESPACE::QueryType                                          queryType,
         size_t                                                                   stride ) const;
 
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceAddress getAccelerationStructureAddressKHR(
+        const AccelerationStructureDeviceAddressInfoKHR & info ) const VULKAN_HPP_NOEXCEPT;
+
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR
+        getAccelerationStructureCompatibilityKHR( const AccelerationStructureVersionInfoKHR & versionInfo ) const
+        VULKAN_HPP_NOEXCEPT;
+
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR
+        getAccelerationStructureBuildSizesKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType,
+                                               const AccelerationStructureBuildGeometryInfoKHR &       buildInfo,
+                                               ArrayProxy<const uint32_t> const & maxPrimitiveCounts
+                                                 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const
+        VULKAN_HPP_NOEXCEPT;
+
+      //=== VK_KHR_sampler_ycbcr_conversion ===
+
+      void destroySamplerYcbcrConversionKHR(
+        VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
+        Optional<const AllocationCallbacks> allocator
+          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+      //=== VK_KHR_bind_memory2 ===
+
+      void bindBufferMemory2KHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos ) const;
+
+      void bindImageMemory2KHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos ) const;
+
+      //=== VK_NV_ray_tracing ===
+
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR getAccelerationStructureMemoryRequirementsNV(
+        const AccelerationStructureMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT;
+
+      template <typename X, typename Y, typename... Z>
+      VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getAccelerationStructureMemoryRequirementsNV(
+        const AccelerationStructureMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT;
+
+      void bindAccelerationStructureMemoryNV(
+        ArrayProxy<const VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV> const & bindInfos ) const;
+
+      //=== VK_KHR_maintenance3 ===
+
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport
+        getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT;
+
+      template <typename X, typename Y, typename... Z>
+      VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
+        getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT;
+
+      //=== VK_EXT_external_memory_host ===
+
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT
+        getMemoryHostPointerPropertiesEXT( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
+                                           const void *                                           pHostPointer ) const;
+
+      //=== VK_EXT_calibrated_timestamps ===
+
+      VULKAN_HPP_NODISCARD std::pair<std::vector<uint64_t>, uint64_t> getCalibratedTimestampsEXT(
+        ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT> const & timestampInfos ) const;
+
+      //=== VK_KHR_timeline_semaphore ===
+
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitSemaphoresKHR( const SemaphoreWaitInfo & waitInfo,
+                                                                           uint64_t                  timeout ) const;
+
+      void signalSemaphoreKHR( const SemaphoreSignalInfo & signalInfo ) const;
+
+      //=== VK_INTEL_performance_query ===
+
+      void initializePerformanceApiINTEL( const InitializePerformanceApiInfoINTEL & initializeInfo ) const;
+
+      void uninitializePerformanceApiINTEL() const VULKAN_HPP_NOEXCEPT;
+
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PerformanceValueINTEL
+        getPerformanceParameterINTEL( VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL parameter ) const;
+
+      //=== VK_EXT_buffer_device_address ===
+
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceAddress
+                           getBufferAddressEXT( const BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT;
+
+#  if defined( VK_USE_PLATFORM_WIN32_KHR )
+      //=== VK_EXT_full_screen_exclusive ===
+
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR
+                           getGroupSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const;
+#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+      //=== VK_KHR_buffer_device_address ===
+
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceAddress
+                           getBufferAddressKHR( const BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT;
+
+      VULKAN_HPP_NODISCARD uint64_t
+        getBufferOpaqueCaptureAddressKHR( const BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT;
+
+      VULKAN_HPP_NODISCARD uint64_t
+        getMemoryOpaqueCaptureAddressKHR( const DeviceMemoryOpaqueCaptureAddressInfo & info ) const VULKAN_HPP_NOEXCEPT;
+
+      //=== VK_KHR_pipeline_executable_properties ===
+
+      VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR>
+                           getPipelineExecutablePropertiesKHR( const PipelineInfoKHR & pipelineInfo ) const;
+
+      VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR>
+                           getPipelineExecutableStatisticsKHR( const PipelineExecutableInfoKHR & executableInfo ) const;
+
+      VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR>
+        getPipelineExecutableInternalRepresentationsKHR( const PipelineExecutableInfoKHR & executableInfo ) const;
+
+      //=== VK_NV_device_generated_commands ===
+
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getGeneratedCommandsMemoryRequirementsNV(
+        const GeneratedCommandsMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT;
+
+      template <typename X, typename Y, typename... Z>
+      VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getGeneratedCommandsMemoryRequirementsNV(
+        const GeneratedCommandsMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT;
+
+      //=== VK_EXT_private_data ===
+
+      void setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType         objectType_,
+                              uint64_t                                 objectHandle,
+                              VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot,
+                              uint64_t                                 data ) const;
+
+      VULKAN_HPP_NODISCARD uint64_t
+        getPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType         objectType_,
+                           uint64_t                                 objectHandle,
+                           VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot ) const VULKAN_HPP_NOEXCEPT;
+
+#  if defined( VK_USE_PLATFORM_FUCHSIA )
+      //=== VK_FUCHSIA_external_memory ===
+
+      VULKAN_HPP_NODISCARD zx_handle_t
+        getMemoryZirconHandleFUCHSIA( const MemoryGetZirconHandleInfoFUCHSIA & getZirconHandleInfo ) const;
+
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA
+        getMemoryZirconHandlePropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
+                                                zx_handle_t zirconHandle ) const;
+#  endif /*VK_USE_PLATFORM_FUCHSIA*/
+
+#  if defined( VK_USE_PLATFORM_FUCHSIA )
+      //=== VK_FUCHSIA_external_semaphore ===
+
+      void importSemaphoreZirconHandleFUCHSIA(
+        const ImportSemaphoreZirconHandleInfoFUCHSIA & importSemaphoreZirconHandleInfo ) const;
+
+      VULKAN_HPP_NODISCARD zx_handle_t
+        getSemaphoreZirconHandleFUCHSIA( const SemaphoreGetZirconHandleInfoFUCHSIA & getZirconHandleInfo ) const;
+#  endif /*VK_USE_PLATFORM_FUCHSIA*/
+
       VULKAN_HPP_NAMESPACE::Device const & operator*() const VULKAN_HPP_NOEXCEPT
       {
         return m_device;
@@ -2755,6 +2883,8 @@ namespace VULKAN_HPP_NAMESPACE
         return *this;
       }
 
+      //=== VK_NV_ray_tracing ===
+
       template <typename T>
       VULKAN_HPP_NODISCARD std::vector<T> getHandle( size_t dataSize ) const;
 
@@ -2848,6 +2978,8 @@ namespace VULKAN_HPP_NAMESPACE
         return *this;
       }
 
+      //=== VK_VERSION_1_0 ===
+
       void bindMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset ) const;
 
       VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements getMemoryRequirements() const VULKAN_HPP_NOEXCEPT;
@@ -3026,11 +3158,17 @@ namespace VULKAN_HPP_NAMESPACE
         return *this;
       }
 
+      //=== VK_VERSION_1_0 ===
+
       void reset( VULKAN_HPP_NAMESPACE::CommandPoolResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const;
 
+      //=== VK_VERSION_1_1 ===
+
       void trim( VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const
         VULKAN_HPP_NOEXCEPT;
 
+      //=== VK_KHR_maintenance1 ===
+
       void trimKHR( VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const
         VULKAN_HPP_NOEXCEPT;
 
@@ -3110,41 +3248,41 @@ namespace VULKAN_HPP_NAMESPACE
         return *this;
       }
 
+      //=== VK_VERSION_1_0 ===
+
       void begin( const CommandBufferBeginInfo & beginInfo ) const;
 
-      void beginConditionalRenderingEXT( const ConditionalRenderingBeginInfoEXT & conditionalRenderingBegin ) const
-        VULKAN_HPP_NOEXCEPT;
+      void end() const;
 
-      void beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT;
+      void reset( VULKAN_HPP_NAMESPACE::CommandBufferResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const;
 
-      void beginQuery( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
-                       uint32_t                        query,
-                       VULKAN_HPP_NAMESPACE::QueryControlFlags flags
-                         VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+      void bindPipeline( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
+                         VULKAN_HPP_NAMESPACE::Pipeline          pipeline ) const VULKAN_HPP_NOEXCEPT;
 
-      void beginQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool         queryPool,
-                                 uint32_t                                query,
-                                 VULKAN_HPP_NAMESPACE::QueryControlFlags flags,
-                                 uint32_t                                index ) const VULKAN_HPP_NOEXCEPT;
+      void setViewport( uint32_t                                                 firstViewport,
+                        ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports ) const VULKAN_HPP_NOEXCEPT;
 
-      void beginRenderPass( const RenderPassBeginInfo &           renderPassBegin,
-                            VULKAN_HPP_NAMESPACE::SubpassContents contents ) const VULKAN_HPP_NOEXCEPT;
+      void setScissor( uint32_t                                               firstScissor,
+                       ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors ) const VULKAN_HPP_NOEXCEPT;
 
-      void beginRenderPass2( const RenderPassBeginInfo & renderPassBegin,
-                             const SubpassBeginInfo &    subpassBeginInfo ) const VULKAN_HPP_NOEXCEPT;
+      void setLineWidth( float lineWidth ) const VULKAN_HPP_NOEXCEPT;
 
-      void beginRenderPass2KHR( const RenderPassBeginInfo & renderPassBegin,
-                                const SubpassBeginInfo &    subpassBeginInfo ) const VULKAN_HPP_NOEXCEPT;
+      void setDepthBias( float depthBiasConstantFactor,
+                         float depthBiasClamp,
+                         float depthBiasSlopeFactor ) const VULKAN_HPP_NOEXCEPT;
 
-      void beginTransformFeedbackEXT( uint32_t                                               firstCounterBuffer,
-                                      ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & counterBuffers,
-                                      ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets
-                                        VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const
-        VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
+      void setBlendConstants( const float blendConstants[4] ) const VULKAN_HPP_NOEXCEPT;
 
-#  if defined( VK_ENABLE_BETA_EXTENSIONS )
-      void beginVideoCodingKHR( const VideoBeginCodingInfoKHR & beginInfo ) const VULKAN_HPP_NOEXCEPT;
-#  endif /*VK_ENABLE_BETA_EXTENSIONS*/
+      void setDepthBounds( float minDepthBounds, float maxDepthBounds ) const VULKAN_HPP_NOEXCEPT;
+
+      void setStencilCompareMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
+                                  uint32_t                               compareMask ) const VULKAN_HPP_NOEXCEPT;
+
+      void setStencilWriteMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
+                                uint32_t                               writeMask ) const VULKAN_HPP_NOEXCEPT;
+
+      void setStencilReference( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
+                                uint32_t                               reference ) const VULKAN_HPP_NOEXCEPT;
 
       void bindDescriptorSets( VULKAN_HPP_NAMESPACE::PipelineBindPoint                       pipelineBindPoint,
                                VULKAN_HPP_NAMESPACE::PipelineLayout                          layout,
@@ -3156,35 +3294,46 @@ namespace VULKAN_HPP_NAMESPACE
                             VULKAN_HPP_NAMESPACE::DeviceSize offset,
                             VULKAN_HPP_NAMESPACE::IndexType  indexType ) const VULKAN_HPP_NOEXCEPT;
 
-      void bindPipeline( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
-                         VULKAN_HPP_NAMESPACE::Pipeline          pipeline ) const VULKAN_HPP_NOEXCEPT;
-
-      void bindPipelineShaderGroupNV( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
-                                      VULKAN_HPP_NAMESPACE::Pipeline          pipeline,
-                                      uint32_t                                groupIndex ) const VULKAN_HPP_NOEXCEPT;
-
-      void bindShadingRateImageNV( VULKAN_HPP_NAMESPACE::ImageView   imageView,
-                                   VULKAN_HPP_NAMESPACE::ImageLayout imageLayout ) const VULKAN_HPP_NOEXCEPT;
-
-      void bindTransformFeedbackBuffersEXT( uint32_t                                                   firstBinding,
-                                            ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &     buffers,
-                                            ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,
-                                            ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes
-                                              VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const
-        VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
-
       void bindVertexBuffers( uint32_t                                                   firstBinding,
                               ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &     buffers,
                               ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets ) const
         VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
 
-      void bindVertexBuffers2EXT(
-        uint32_t                                                         firstBinding,
-        ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &           buffers,
-        ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const &       offsets,
-        ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-        ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & strides
-          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
+      void draw( uint32_t vertexCount,
+                 uint32_t instanceCount,
+                 uint32_t firstVertex,
+                 uint32_t firstInstance ) const VULKAN_HPP_NOEXCEPT;
+
+      void drawIndexed( uint32_t indexCount,
+                        uint32_t instanceCount,
+                        uint32_t firstIndex,
+                        int32_t  vertexOffset,
+                        uint32_t firstInstance ) const VULKAN_HPP_NOEXCEPT;
+
+      void drawIndirect( VULKAN_HPP_NAMESPACE::Buffer     buffer,
+                         VULKAN_HPP_NAMESPACE::DeviceSize offset,
+                         uint32_t                         drawCount,
+                         uint32_t                         stride ) const VULKAN_HPP_NOEXCEPT;
+
+      void drawIndexedIndirect( VULKAN_HPP_NAMESPACE::Buffer     buffer,
+                                VULKAN_HPP_NAMESPACE::DeviceSize offset,
+                                uint32_t                         drawCount,
+                                uint32_t                         stride ) const VULKAN_HPP_NOEXCEPT;
+
+      void dispatch( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT;
+
+      void dispatchIndirect( VULKAN_HPP_NAMESPACE::Buffer     buffer,
+                             VULKAN_HPP_NAMESPACE::DeviceSize offset ) const VULKAN_HPP_NOEXCEPT;
+
+      void copyBuffer( VULKAN_HPP_NAMESPACE::Buffer                               srcBuffer,
+                       VULKAN_HPP_NAMESPACE::Buffer                               dstBuffer,
+                       ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferCopy> const & regions ) const VULKAN_HPP_NOEXCEPT;
+
+      void copyImage( VULKAN_HPP_NAMESPACE::Image                               srcImage,
+                      VULKAN_HPP_NAMESPACE::ImageLayout                         srcImageLayout,
+                      VULKAN_HPP_NAMESPACE::Image                               dstImage,
+                      VULKAN_HPP_NAMESPACE::ImageLayout                         dstImageLayout,
+                      ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageCopy> const & regions ) const VULKAN_HPP_NOEXCEPT;
 
       void blitImage( VULKAN_HPP_NAMESPACE::Image                               srcImage,
                       VULKAN_HPP_NAMESPACE::ImageLayout                         srcImageLayout,
@@ -3193,31 +3342,27 @@ namespace VULKAN_HPP_NAMESPACE
                       ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageBlit> const & regions,
                       VULKAN_HPP_NAMESPACE::Filter                              filter ) const VULKAN_HPP_NOEXCEPT;
 
-      void blitImage2KHR( const BlitImageInfo2KHR & blitImageInfo ) const VULKAN_HPP_NOEXCEPT;
+      void copyBufferToImage( VULKAN_HPP_NAMESPACE::Buffer                                    srcBuffer,
+                              VULKAN_HPP_NAMESPACE::Image                                     dstImage,
+                              VULKAN_HPP_NAMESPACE::ImageLayout                               dstImageLayout,
+                              ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions ) const
+        VULKAN_HPP_NOEXCEPT;
 
-      void buildAccelerationStructureNV( const AccelerationStructureInfoNV &           info,
-                                         VULKAN_HPP_NAMESPACE::Buffer                  instanceData,
-                                         VULKAN_HPP_NAMESPACE::DeviceSize              instanceOffset,
-                                         VULKAN_HPP_NAMESPACE::Bool32                  update,
-                                         VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst,
-                                         VULKAN_HPP_NAMESPACE::AccelerationStructureNV src,
-                                         VULKAN_HPP_NAMESPACE::Buffer                  scratch,
-                                         VULKAN_HPP_NAMESPACE::DeviceSize scratchOffset ) const VULKAN_HPP_NOEXCEPT;
+      void copyImageToBuffer( VULKAN_HPP_NAMESPACE::Image                                     srcImage,
+                              VULKAN_HPP_NAMESPACE::ImageLayout                               srcImageLayout,
+                              VULKAN_HPP_NAMESPACE::Buffer                                    dstBuffer,
+                              ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions ) const
+        VULKAN_HPP_NOEXCEPT;
 
-      void buildAccelerationStructuresIndirectKHR(
-        ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos,
-        ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceAddress> const & indirectDeviceAddresses,
-        ArrayProxy<const uint32_t> const &                            indirectStrides,
-        ArrayProxy<const uint32_t * const> const & pMaxPrimitiveCounts ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
+      template <typename T>
+      void updateBuffer( VULKAN_HPP_NAMESPACE::Buffer     dstBuffer,
+                         VULKAN_HPP_NAMESPACE::DeviceSize dstOffset,
+                         ArrayProxy<const T> const &      data ) const VULKAN_HPP_NOEXCEPT;
 
-      void buildAccelerationStructuresKHR(
-        ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos,
-        ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const> const &
-          pBuildRangeInfos ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
-
-      void
-        clearAttachments( ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearAttachment> const & attachments,
-                          ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearRect> const & rects ) const VULKAN_HPP_NOEXCEPT;
+      void fillBuffer( VULKAN_HPP_NAMESPACE::Buffer     dstBuffer,
+                       VULKAN_HPP_NAMESPACE::DeviceSize dstOffset,
+                       VULKAN_HPP_NAMESPACE::DeviceSize size,
+                       uint32_t                         data ) const VULKAN_HPP_NOEXCEPT;
 
       void clearColorImage( VULKAN_HPP_NAMESPACE::Image                                           image,
                             VULKAN_HPP_NAMESPACE::ImageLayout                                     imageLayout,
@@ -3231,52 +3376,53 @@ namespace VULKAN_HPP_NAMESPACE
                                    ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceRange> const & ranges ) const
         VULKAN_HPP_NOEXCEPT;
 
-#  if defined( VK_ENABLE_BETA_EXTENSIONS )
-      void controlVideoCodingKHR( const VideoCodingControlInfoKHR & codingControlInfo ) const VULKAN_HPP_NOEXCEPT;
-#  endif /*VK_ENABLE_BETA_EXTENSIONS*/
+      void
+        clearAttachments( ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearAttachment> const & attachments,
+                          ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearRect> const & rects ) const VULKAN_HPP_NOEXCEPT;
 
-      void copyAccelerationStructureKHR( const CopyAccelerationStructureInfoKHR & info ) const VULKAN_HPP_NOEXCEPT;
+      void
+        resolveImage( VULKAN_HPP_NAMESPACE::Image                                  srcImage,
+                      VULKAN_HPP_NAMESPACE::ImageLayout                            srcImageLayout,
+                      VULKAN_HPP_NAMESPACE::Image                                  dstImage,
+                      VULKAN_HPP_NAMESPACE::ImageLayout                            dstImageLayout,
+                      ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageResolve> const & regions ) const VULKAN_HPP_NOEXCEPT;
 
-      void copyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV          dst,
-                                        VULKAN_HPP_NAMESPACE::AccelerationStructureNV          src,
-                                        VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR mode ) const
+      void setEvent( VULKAN_HPP_NAMESPACE::Event              event,
+                     VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask ) const VULKAN_HPP_NOEXCEPT;
+
+      void resetEvent( VULKAN_HPP_NAMESPACE::Event              event,
+                       VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask ) const VULKAN_HPP_NOEXCEPT;
+
+      void waitEvents( ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const &               events,
+                       VULKAN_HPP_NAMESPACE::PipelineStageFlags                            srcStageMask,
+                       VULKAN_HPP_NAMESPACE::PipelineStageFlags                            dstStageMask,
+                       ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const &       memoryBarriers,
+                       ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const & bufferMemoryBarriers,
+                       ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const &  imageMemoryBarriers ) const
         VULKAN_HPP_NOEXCEPT;
 
-      void copyAccelerationStructureToMemoryKHR( const CopyAccelerationStructureToMemoryInfoKHR & info ) const
-        VULKAN_HPP_NOEXCEPT;
+      void pipelineBarrier( VULKAN_HPP_NAMESPACE::PipelineStageFlags                            srcStageMask,
+                            VULKAN_HPP_NAMESPACE::PipelineStageFlags                            dstStageMask,
+                            VULKAN_HPP_NAMESPACE::DependencyFlags                               dependencyFlags,
+                            ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const &       memoryBarriers,
+                            ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const & bufferMemoryBarriers,
+                            ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const &  imageMemoryBarriers )
+        const VULKAN_HPP_NOEXCEPT;
 
-      void copyBuffer( VULKAN_HPP_NAMESPACE::Buffer                               srcBuffer,
-                       VULKAN_HPP_NAMESPACE::Buffer                               dstBuffer,
-                       ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferCopy> const & regions ) const VULKAN_HPP_NOEXCEPT;
+      void beginQuery( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
+                       uint32_t                        query,
+                       VULKAN_HPP_NAMESPACE::QueryControlFlags flags
+                         VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 
-      void copyBuffer2KHR( const CopyBufferInfo2KHR & copyBufferInfo ) const VULKAN_HPP_NOEXCEPT;
+      void endQuery( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT;
 
-      void copyBufferToImage( VULKAN_HPP_NAMESPACE::Buffer                                    srcBuffer,
-                              VULKAN_HPP_NAMESPACE::Image                                     dstImage,
-                              VULKAN_HPP_NAMESPACE::ImageLayout                               dstImageLayout,
-                              ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions ) const
-        VULKAN_HPP_NOEXCEPT;
+      void resetQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
+                           uint32_t                        firstQuery,
+                           uint32_t                        queryCount ) const VULKAN_HPP_NOEXCEPT;
 
-      void copyBufferToImage2KHR( const CopyBufferToImageInfo2KHR & copyBufferToImageInfo ) const VULKAN_HPP_NOEXCEPT;
-
-      void copyImage( VULKAN_HPP_NAMESPACE::Image                               srcImage,
-                      VULKAN_HPP_NAMESPACE::ImageLayout                         srcImageLayout,
-                      VULKAN_HPP_NAMESPACE::Image                               dstImage,
-                      VULKAN_HPP_NAMESPACE::ImageLayout                         dstImageLayout,
-                      ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageCopy> const & regions ) const VULKAN_HPP_NOEXCEPT;
-
-      void copyImage2KHR( const CopyImageInfo2KHR & copyImageInfo ) const VULKAN_HPP_NOEXCEPT;
-
-      void copyImageToBuffer( VULKAN_HPP_NAMESPACE::Image                                     srcImage,
-                              VULKAN_HPP_NAMESPACE::ImageLayout                               srcImageLayout,
-                              VULKAN_HPP_NAMESPACE::Buffer                                    dstBuffer,
-                              ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions ) const
-        VULKAN_HPP_NOEXCEPT;
-
-      void copyImageToBuffer2KHR( const CopyImageToBufferInfo2KHR & copyImageToBufferInfo ) const VULKAN_HPP_NOEXCEPT;
-
-      void copyMemoryToAccelerationStructureKHR( const CopyMemoryToAccelerationStructureInfoKHR & info ) const
-        VULKAN_HPP_NOEXCEPT;
+      void writeTimestamp( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage,
+                           VULKAN_HPP_NAMESPACE::QueryPool             queryPool,
+                           uint32_t                                    query ) const VULKAN_HPP_NOEXCEPT;
 
       void copyQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool  queryPool,
                                  uint32_t                         firstQuery,
@@ -3287,19 +3433,25 @@ namespace VULKAN_HPP_NAMESPACE
                                  VULKAN_HPP_NAMESPACE::QueryResultFlags flags
                                    VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 
-      void cuLaunchKernelNVX( const CuLaunchInfoNVX & launchInfo ) const VULKAN_HPP_NOEXCEPT;
+      template <typename T>
+      void pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout   layout,
+                          VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags,
+                          uint32_t                               offset,
+                          ArrayProxy<const T> const &            values ) const VULKAN_HPP_NOEXCEPT;
 
-      void debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT & markerInfo ) const VULKAN_HPP_NOEXCEPT;
+      void beginRenderPass( const RenderPassBeginInfo &           renderPassBegin,
+                            VULKAN_HPP_NAMESPACE::SubpassContents contents ) const VULKAN_HPP_NOEXCEPT;
 
-      void debugMarkerEndEXT() const VULKAN_HPP_NOEXCEPT;
+      void nextSubpass( VULKAN_HPP_NAMESPACE::SubpassContents contents ) const VULKAN_HPP_NOEXCEPT;
 
-      void debugMarkerInsertEXT( const DebugMarkerMarkerInfoEXT & markerInfo ) const VULKAN_HPP_NOEXCEPT;
+      void endRenderPass() const VULKAN_HPP_NOEXCEPT;
 
-#  if defined( VK_ENABLE_BETA_EXTENSIONS )
-      void decodeVideoKHR( const VideoDecodeInfoKHR & frameInfo ) const VULKAN_HPP_NOEXCEPT;
-#  endif /*VK_ENABLE_BETA_EXTENSIONS*/
+      void executeCommands( ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers ) const
+        VULKAN_HPP_NOEXCEPT;
 
-      void dispatch( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT;
+      //=== VK_VERSION_1_1 ===
+
+      void setDeviceMask( uint32_t deviceMask ) const VULKAN_HPP_NOEXCEPT;
 
       void dispatchBase( uint32_t baseGroupX,
                          uint32_t baseGroupY,
@@ -3308,64 +3460,7 @@ namespace VULKAN_HPP_NAMESPACE
                          uint32_t groupCountY,
                          uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT;
 
-      void dispatchBaseKHR( uint32_t baseGroupX,
-                            uint32_t baseGroupY,
-                            uint32_t baseGroupZ,
-                            uint32_t groupCountX,
-                            uint32_t groupCountY,
-                            uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT;
-
-      void dispatchIndirect( VULKAN_HPP_NAMESPACE::Buffer     buffer,
-                             VULKAN_HPP_NAMESPACE::DeviceSize offset ) const VULKAN_HPP_NOEXCEPT;
-
-      void draw( uint32_t vertexCount,
-                 uint32_t instanceCount,
-                 uint32_t firstVertex,
-                 uint32_t firstInstance ) const VULKAN_HPP_NOEXCEPT;
-
-      void drawIndexed( uint32_t indexCount,
-                        uint32_t instanceCount,
-                        uint32_t firstIndex,
-                        int32_t  vertexOffset,
-                        uint32_t firstInstance ) const VULKAN_HPP_NOEXCEPT;
-
-      void drawIndexedIndirect( VULKAN_HPP_NAMESPACE::Buffer     buffer,
-                                VULKAN_HPP_NAMESPACE::DeviceSize offset,
-                                uint32_t                         drawCount,
-                                uint32_t                         stride ) const VULKAN_HPP_NOEXCEPT;
-
-      void drawIndexedIndirectCount( VULKAN_HPP_NAMESPACE::Buffer     buffer,
-                                     VULKAN_HPP_NAMESPACE::DeviceSize offset,
-                                     VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
-                                     VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
-                                     uint32_t                         maxDrawCount,
-                                     uint32_t                         stride ) const VULKAN_HPP_NOEXCEPT;
-
-      void drawIndexedIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer     buffer,
-                                        VULKAN_HPP_NAMESPACE::DeviceSize offset,
-                                        VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
-                                        VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
-                                        uint32_t                         maxDrawCount,
-                                        uint32_t                         stride ) const VULKAN_HPP_NOEXCEPT;
-
-      void drawIndexedIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer     buffer,
-                                        VULKAN_HPP_NAMESPACE::DeviceSize offset,
-                                        VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
-                                        VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
-                                        uint32_t                         maxDrawCount,
-                                        uint32_t                         stride ) const VULKAN_HPP_NOEXCEPT;
-
-      void drawIndirect( VULKAN_HPP_NAMESPACE::Buffer     buffer,
-                         VULKAN_HPP_NAMESPACE::DeviceSize offset,
-                         uint32_t                         drawCount,
-                         uint32_t                         stride ) const VULKAN_HPP_NOEXCEPT;
-
-      void drawIndirectByteCountEXT( uint32_t                         instanceCount,
-                                     uint32_t                         firstInstance,
-                                     VULKAN_HPP_NAMESPACE::Buffer     counterBuffer,
-                                     VULKAN_HPP_NAMESPACE::DeviceSize counterBufferOffset,
-                                     uint32_t                         counterOffset,
-                                     uint32_t                         vertexStride ) const VULKAN_HPP_NOEXCEPT;
+      //=== VK_VERSION_1_2 ===
 
       void drawIndirectCount( VULKAN_HPP_NAMESPACE::Buffer     buffer,
                               VULKAN_HPP_NAMESPACE::DeviceSize offset,
@@ -3374,53 +3469,59 @@ namespace VULKAN_HPP_NAMESPACE
                               uint32_t                         maxDrawCount,
                               uint32_t                         stride ) const VULKAN_HPP_NOEXCEPT;
 
-      void drawIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer     buffer,
-                                 VULKAN_HPP_NAMESPACE::DeviceSize offset,
-                                 VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
-                                 VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
-                                 uint32_t                         maxDrawCount,
-                                 uint32_t                         stride ) const VULKAN_HPP_NOEXCEPT;
+      void drawIndexedIndirectCount( VULKAN_HPP_NAMESPACE::Buffer     buffer,
+                                     VULKAN_HPP_NAMESPACE::DeviceSize offset,
+                                     VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
+                                     VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
+                                     uint32_t                         maxDrawCount,
+                                     uint32_t                         stride ) const VULKAN_HPP_NOEXCEPT;
 
-      void drawIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer     buffer,
-                                 VULKAN_HPP_NAMESPACE::DeviceSize offset,
-                                 VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
-                                 VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
-                                 uint32_t                         maxDrawCount,
-                                 uint32_t                         stride ) const VULKAN_HPP_NOEXCEPT;
+      void beginRenderPass2( const RenderPassBeginInfo & renderPassBegin,
+                             const SubpassBeginInfo &    subpassBeginInfo ) const VULKAN_HPP_NOEXCEPT;
 
-      void drawMeshTasksIndirectCountNV( VULKAN_HPP_NAMESPACE::Buffer     buffer,
-                                         VULKAN_HPP_NAMESPACE::DeviceSize offset,
-                                         VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
-                                         VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
-                                         uint32_t                         maxDrawCount,
-                                         uint32_t                         stride ) const VULKAN_HPP_NOEXCEPT;
-
-      void drawMeshTasksIndirectNV( VULKAN_HPP_NAMESPACE::Buffer     buffer,
-                                    VULKAN_HPP_NAMESPACE::DeviceSize offset,
-                                    uint32_t                         drawCount,
-                                    uint32_t                         stride ) const VULKAN_HPP_NOEXCEPT;
-
-      void drawMeshTasksNV( uint32_t taskCount, uint32_t firstTask ) const VULKAN_HPP_NOEXCEPT;
-
-#  if defined( VK_ENABLE_BETA_EXTENSIONS )
-      void encodeVideoKHR( const VideoEncodeInfoKHR & encodeInfo ) const VULKAN_HPP_NOEXCEPT;
-#  endif /*VK_ENABLE_BETA_EXTENSIONS*/
-
-      void endConditionalRenderingEXT() const VULKAN_HPP_NOEXCEPT;
-
-      void endDebugUtilsLabelEXT() const VULKAN_HPP_NOEXCEPT;
-
-      void endQuery( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT;
-
-      void endQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
-                               uint32_t                        query,
-                               uint32_t                        index ) const VULKAN_HPP_NOEXCEPT;
-
-      void endRenderPass() const VULKAN_HPP_NOEXCEPT;
+      void nextSubpass2( const SubpassBeginInfo & subpassBeginInfo,
+                         const SubpassEndInfo &   subpassEndInfo ) const VULKAN_HPP_NOEXCEPT;
 
       void endRenderPass2( const SubpassEndInfo & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT;
 
-      void endRenderPass2KHR( const SubpassEndInfo & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT;
+      //=== VK_EXT_debug_marker ===
+
+      void debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT & markerInfo ) const VULKAN_HPP_NOEXCEPT;
+
+      void debugMarkerEndEXT() const VULKAN_HPP_NOEXCEPT;
+
+      void debugMarkerInsertEXT( const DebugMarkerMarkerInfoEXT & markerInfo ) const VULKAN_HPP_NOEXCEPT;
+
+#  if defined( VK_ENABLE_BETA_EXTENSIONS )
+      //=== VK_KHR_video_queue ===
+
+      void beginVideoCodingKHR( const VideoBeginCodingInfoKHR & beginInfo ) const VULKAN_HPP_NOEXCEPT;
+
+      void endVideoCodingKHR( const VideoEndCodingInfoKHR & endCodingInfo ) const VULKAN_HPP_NOEXCEPT;
+
+      void controlVideoCodingKHR( const VideoCodingControlInfoKHR & codingControlInfo ) const VULKAN_HPP_NOEXCEPT;
+#  endif /*VK_ENABLE_BETA_EXTENSIONS*/
+
+#  if defined( VK_ENABLE_BETA_EXTENSIONS )
+      //=== VK_KHR_video_decode_queue ===
+
+      void decodeVideoKHR( const VideoDecodeInfoKHR & frameInfo ) const VULKAN_HPP_NOEXCEPT;
+#  endif /*VK_ENABLE_BETA_EXTENSIONS*/
+
+      //=== VK_EXT_transform_feedback ===
+
+      void bindTransformFeedbackBuffersEXT( uint32_t                                                   firstBinding,
+                                            ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &     buffers,
+                                            ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,
+                                            ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes
+                                              VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const
+        VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
+
+      void beginTransformFeedbackEXT( uint32_t                                               firstCounterBuffer,
+                                      ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & counterBuffers,
+                                      ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets
+                                        VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const
+        VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
 
       void endTransformFeedbackEXT( uint32_t                                               firstCounterBuffer,
                                     ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & counterBuffers,
@@ -3428,50 +3529,54 @@ namespace VULKAN_HPP_NAMESPACE
                                       VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const
         VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
 
-#  if defined( VK_ENABLE_BETA_EXTENSIONS )
-      void endVideoCodingKHR( const VideoEndCodingInfoKHR & endCodingInfo ) const VULKAN_HPP_NOEXCEPT;
-#  endif /*VK_ENABLE_BETA_EXTENSIONS*/
+      void beginQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool         queryPool,
+                                 uint32_t                                query,
+                                 VULKAN_HPP_NAMESPACE::QueryControlFlags flags,
+                                 uint32_t                                index ) const VULKAN_HPP_NOEXCEPT;
 
-      void executeCommands( ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers ) const
-        VULKAN_HPP_NOEXCEPT;
+      void endQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
+                               uint32_t                        query,
+                               uint32_t                        index ) const VULKAN_HPP_NOEXCEPT;
 
-      void
-        executeGeneratedCommandsNV( VULKAN_HPP_NAMESPACE::Bool32    isPreprocessed,
-                                    const GeneratedCommandsInfoNV & generatedCommandsInfo ) const VULKAN_HPP_NOEXCEPT;
+      void drawIndirectByteCountEXT( uint32_t                         instanceCount,
+                                     uint32_t                         firstInstance,
+                                     VULKAN_HPP_NAMESPACE::Buffer     counterBuffer,
+                                     VULKAN_HPP_NAMESPACE::DeviceSize counterBufferOffset,
+                                     uint32_t                         counterOffset,
+                                     uint32_t                         vertexStride ) const VULKAN_HPP_NOEXCEPT;
 
-      void fillBuffer( VULKAN_HPP_NAMESPACE::Buffer     dstBuffer,
-                       VULKAN_HPP_NAMESPACE::DeviceSize dstOffset,
-                       VULKAN_HPP_NAMESPACE::DeviceSize size,
-                       uint32_t                         data ) const VULKAN_HPP_NOEXCEPT;
+      //=== VK_NVX_binary_import ===
 
-      void insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT;
+      void cuLaunchKernelNVX( const CuLaunchInfoNVX & launchInfo ) const VULKAN_HPP_NOEXCEPT;
 
-      void nextSubpass( VULKAN_HPP_NAMESPACE::SubpassContents contents ) const VULKAN_HPP_NOEXCEPT;
+      //=== VK_AMD_draw_indirect_count ===
 
-      void nextSubpass2( const SubpassBeginInfo & subpassBeginInfo,
-                         const SubpassEndInfo &   subpassEndInfo ) const VULKAN_HPP_NOEXCEPT;
+      void drawIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer     buffer,
+                                 VULKAN_HPP_NAMESPACE::DeviceSize offset,
+                                 VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
+                                 VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
+                                 uint32_t                         maxDrawCount,
+                                 uint32_t                         stride ) const VULKAN_HPP_NOEXCEPT;
 
-      void nextSubpass2KHR( const SubpassBeginInfo & subpassBeginInfo,
-                            const SubpassEndInfo &   subpassEndInfo ) const VULKAN_HPP_NOEXCEPT;
+      void drawIndexedIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer     buffer,
+                                        VULKAN_HPP_NAMESPACE::DeviceSize offset,
+                                        VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
+                                        VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
+                                        uint32_t                         maxDrawCount,
+                                        uint32_t                         stride ) const VULKAN_HPP_NOEXCEPT;
 
-      void pipelineBarrier( VULKAN_HPP_NAMESPACE::PipelineStageFlags                            srcStageMask,
-                            VULKAN_HPP_NAMESPACE::PipelineStageFlags                            dstStageMask,
-                            VULKAN_HPP_NAMESPACE::DependencyFlags                               dependencyFlags,
-                            ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const &       memoryBarriers,
-                            ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const & bufferMemoryBarriers,
-                            ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const &  imageMemoryBarriers )
-        const VULKAN_HPP_NOEXCEPT;
+      //=== VK_KHR_device_group ===
 
-      void pipelineBarrier2KHR( const DependencyInfoKHR & dependencyInfo ) const VULKAN_HPP_NOEXCEPT;
+      void setDeviceMaskKHR( uint32_t deviceMask ) const VULKAN_HPP_NOEXCEPT;
 
-      void preprocessGeneratedCommandsNV( const GeneratedCommandsInfoNV & generatedCommandsInfo ) const
-        VULKAN_HPP_NOEXCEPT;
+      void dispatchBaseKHR( uint32_t baseGroupX,
+                            uint32_t baseGroupY,
+                            uint32_t baseGroupZ,
+                            uint32_t groupCountX,
+                            uint32_t groupCountY,
+                            uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT;
 
-      template <typename T>
-      void pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout   layout,
-                          VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags,
-                          uint32_t                               offset,
-                          ArrayProxy<const T> const &            values ) const VULKAN_HPP_NOEXCEPT;
+      //=== VK_KHR_push_descriptor ===
 
       void pushDescriptorSetKHR(
         VULKAN_HPP_NAMESPACE::PipelineBindPoint                            pipelineBindPoint,
@@ -3484,165 +3589,102 @@ namespace VULKAN_HPP_NAMESPACE
                                              uint32_t                                       set,
                                              const void * pData ) const VULKAN_HPP_NOEXCEPT;
 
-      void resetEvent( VULKAN_HPP_NAMESPACE::Event              event,
-                       VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask ) const VULKAN_HPP_NOEXCEPT;
+      //=== VK_EXT_conditional_rendering ===
 
-      void resetEvent2KHR( VULKAN_HPP_NAMESPACE::Event                  event,
-                           VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR stageMask ) const VULKAN_HPP_NOEXCEPT;
-
-      void resetQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
-                           uint32_t                        firstQuery,
-                           uint32_t                        queryCount ) const VULKAN_HPP_NOEXCEPT;
-
-      void
-        resolveImage( VULKAN_HPP_NAMESPACE::Image                                  srcImage,
-                      VULKAN_HPP_NAMESPACE::ImageLayout                            srcImageLayout,
-                      VULKAN_HPP_NAMESPACE::Image                                  dstImage,
-                      VULKAN_HPP_NAMESPACE::ImageLayout                            dstImageLayout,
-                      ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageResolve> const & regions ) const VULKAN_HPP_NOEXCEPT;
-
-      void resolveImage2KHR( const ResolveImageInfo2KHR & resolveImageInfo ) const VULKAN_HPP_NOEXCEPT;
-
-      void setBlendConstants( const float blendConstants[4] ) const VULKAN_HPP_NOEXCEPT;
-
-      void setCheckpointNV( const void * pCheckpointMarker ) const VULKAN_HPP_NOEXCEPT;
-
-      void setCoarseSampleOrderNV( VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV sampleOrderType,
-                                   ArrayProxy<const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV> const &
-                                     customSampleOrders ) const VULKAN_HPP_NOEXCEPT;
-
-      void setColorWriteEnableEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & colorWriteEnables ) const
+      void beginConditionalRenderingEXT( const ConditionalRenderingBeginInfoEXT & conditionalRenderingBegin ) const
         VULKAN_HPP_NOEXCEPT;
 
-      void setCullModeEXT( VULKAN_HPP_NAMESPACE::CullModeFlags cullMode VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const
-        VULKAN_HPP_NOEXCEPT;
+      void endConditionalRenderingEXT() const VULKAN_HPP_NOEXCEPT;
 
-      void setDepthBias( float depthBiasConstantFactor,
-                         float depthBiasClamp,
-                         float depthBiasSlopeFactor ) const VULKAN_HPP_NOEXCEPT;
-
-      void setDepthBiasEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable ) const VULKAN_HPP_NOEXCEPT;
-
-      void setDepthBounds( float minDepthBounds, float maxDepthBounds ) const VULKAN_HPP_NOEXCEPT;
-
-      void setDepthBoundsTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable ) const VULKAN_HPP_NOEXCEPT;
-
-      void setDepthCompareOpEXT( VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp ) const VULKAN_HPP_NOEXCEPT;
-
-      void setDepthTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable ) const VULKAN_HPP_NOEXCEPT;
-
-      void setDepthWriteEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable ) const VULKAN_HPP_NOEXCEPT;
-
-      void setDeviceMask( uint32_t deviceMask ) const VULKAN_HPP_NOEXCEPT;
-
-      void setDeviceMaskKHR( uint32_t deviceMask ) const VULKAN_HPP_NOEXCEPT;
-
-      void setDiscardRectangleEXT( uint32_t                                               firstDiscardRectangle,
-                                   ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & discardRectangles ) const
-        VULKAN_HPP_NOEXCEPT;
-
-      void setEvent( VULKAN_HPP_NAMESPACE::Event              event,
-                     VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask ) const VULKAN_HPP_NOEXCEPT;
-
-      void setEvent2KHR( VULKAN_HPP_NAMESPACE::Event event,
-                         const DependencyInfoKHR &   dependencyInfo ) const VULKAN_HPP_NOEXCEPT;
-
-      void setExclusiveScissorNV( uint32_t                                               firstExclusiveScissor,
-                                  ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & exclusiveScissors ) const
-        VULKAN_HPP_NOEXCEPT;
-
-      void setFragmentShadingRateEnumNV(
-        VULKAN_HPP_NAMESPACE::FragmentShadingRateNV                  shadingRate,
-        const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2] ) const VULKAN_HPP_NOEXCEPT;
-
-      void setFragmentShadingRateKHR(
-        const Extent2D &                                             fragmentSize,
-        const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2] ) const VULKAN_HPP_NOEXCEPT;
-
-      void setFrontFaceEXT( VULKAN_HPP_NAMESPACE::FrontFace frontFace ) const VULKAN_HPP_NOEXCEPT;
-
-      void setLineStippleEXT( uint32_t lineStippleFactor, uint16_t lineStipplePattern ) const VULKAN_HPP_NOEXCEPT;
-
-      void setLineWidth( float lineWidth ) const VULKAN_HPP_NOEXCEPT;
-
-      void setLogicOpEXT( VULKAN_HPP_NAMESPACE::LogicOp logicOp ) const VULKAN_HPP_NOEXCEPT;
-
-      void setPatchControlPointsEXT( uint32_t patchControlPoints ) const VULKAN_HPP_NOEXCEPT;
-
-      void setPerformanceMarkerINTEL( const PerformanceMarkerInfoINTEL & markerInfo ) const;
-
-      void setPerformanceOverrideINTEL( const PerformanceOverrideInfoINTEL & overrideInfo ) const;
-
-      void setPerformanceStreamMarkerINTEL( const PerformanceStreamMarkerInfoINTEL & markerInfo ) const;
-
-      void
-        setPrimitiveRestartEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable ) const VULKAN_HPP_NOEXCEPT;
-
-      void
-        setPrimitiveTopologyEXT( VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology ) const VULKAN_HPP_NOEXCEPT;
-
-      void
-        setRasterizerDiscardEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable ) const VULKAN_HPP_NOEXCEPT;
-
-      void setRayTracingPipelineStackSizeKHR( uint32_t pipelineStackSize ) const VULKAN_HPP_NOEXCEPT;
-
-      void setSampleLocationsEXT( const SampleLocationsInfoEXT & sampleLocationsInfo ) const VULKAN_HPP_NOEXCEPT;
-
-      void setScissor( uint32_t                                               firstScissor,
-                       ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors ) const VULKAN_HPP_NOEXCEPT;
-
-      void setScissorWithCountEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors ) const
-        VULKAN_HPP_NOEXCEPT;
-
-      void setStencilCompareMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
-                                  uint32_t                               compareMask ) const VULKAN_HPP_NOEXCEPT;
-
-      void setStencilOpEXT( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
-                            VULKAN_HPP_NAMESPACE::StencilOp        failOp,
-                            VULKAN_HPP_NAMESPACE::StencilOp        passOp,
-                            VULKAN_HPP_NAMESPACE::StencilOp        depthFailOp,
-                            VULKAN_HPP_NAMESPACE::CompareOp        compareOp ) const VULKAN_HPP_NOEXCEPT;
-
-      void setStencilReference( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
-                                uint32_t                               reference ) const VULKAN_HPP_NOEXCEPT;
-
-      void setStencilTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable ) const VULKAN_HPP_NOEXCEPT;
-
-      void setStencilWriteMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
-                                uint32_t                               writeMask ) const VULKAN_HPP_NOEXCEPT;
-
-      void setVertexInputEXT(
-        ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT> const & vertexBindingDescriptions,
-        ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT> const &
-          vertexAttributeDescriptions ) const VULKAN_HPP_NOEXCEPT;
-
-      void setViewport( uint32_t                                                 firstViewport,
-                        ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports ) const VULKAN_HPP_NOEXCEPT;
-
-      void setViewportShadingRatePaletteNV( uint32_t firstViewport,
-                                            ArrayProxy<const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV> const &
-                                              shadingRatePalettes ) const VULKAN_HPP_NOEXCEPT;
+      //=== VK_NV_clip_space_w_scaling ===
 
       void setViewportWScalingNV( uint32_t                                                           firstViewport,
                                   ArrayProxy<const VULKAN_HPP_NAMESPACE::ViewportWScalingNV> const & viewportWScalings )
         const VULKAN_HPP_NOEXCEPT;
 
-      void setViewportWithCountEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports ) const
+      //=== VK_EXT_discard_rectangles ===
+
+      void setDiscardRectangleEXT( uint32_t                                               firstDiscardRectangle,
+                                   ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & discardRectangles ) const
         VULKAN_HPP_NOEXCEPT;
 
-      void traceRaysIndirectKHR( const StridedDeviceAddressRegionKHR & raygenShaderBindingTable,
-                                 const StridedDeviceAddressRegionKHR & missShaderBindingTable,
-                                 const StridedDeviceAddressRegionKHR & hitShaderBindingTable,
-                                 const StridedDeviceAddressRegionKHR & callableShaderBindingTable,
-                                 VULKAN_HPP_NAMESPACE::DeviceAddress indirectDeviceAddress ) const VULKAN_HPP_NOEXCEPT;
+      //=== VK_KHR_create_renderpass2 ===
 
-      void traceRaysKHR( const StridedDeviceAddressRegionKHR & raygenShaderBindingTable,
-                         const StridedDeviceAddressRegionKHR & missShaderBindingTable,
-                         const StridedDeviceAddressRegionKHR & hitShaderBindingTable,
-                         const StridedDeviceAddressRegionKHR & callableShaderBindingTable,
-                         uint32_t                              width,
-                         uint32_t                              height,
-                         uint32_t                              depth ) const VULKAN_HPP_NOEXCEPT;
+      void beginRenderPass2KHR( const RenderPassBeginInfo & renderPassBegin,
+                                const SubpassBeginInfo &    subpassBeginInfo ) const VULKAN_HPP_NOEXCEPT;
+
+      void nextSubpass2KHR( const SubpassBeginInfo & subpassBeginInfo,
+                            const SubpassEndInfo &   subpassEndInfo ) const VULKAN_HPP_NOEXCEPT;
+
+      void endRenderPass2KHR( const SubpassEndInfo & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT;
+
+      //=== VK_EXT_debug_utils ===
+
+      void beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT;
+
+      void endDebugUtilsLabelEXT() const VULKAN_HPP_NOEXCEPT;
+
+      void insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT;
+
+      //=== VK_EXT_sample_locations ===
+
+      void setSampleLocationsEXT( const SampleLocationsInfoEXT & sampleLocationsInfo ) const VULKAN_HPP_NOEXCEPT;
+
+      //=== VK_KHR_acceleration_structure ===
+
+      void buildAccelerationStructuresKHR(
+        ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos,
+        ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const> const &
+          pBuildRangeInfos ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
+
+      void buildAccelerationStructuresIndirectKHR(
+        ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos,
+        ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceAddress> const & indirectDeviceAddresses,
+        ArrayProxy<const uint32_t> const &                            indirectStrides,
+        ArrayProxy<const uint32_t * const> const & pMaxPrimitiveCounts ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
+
+      void copyAccelerationStructureKHR( const CopyAccelerationStructureInfoKHR & info ) const VULKAN_HPP_NOEXCEPT;
+
+      void copyAccelerationStructureToMemoryKHR( const CopyAccelerationStructureToMemoryInfoKHR & info ) const
+        VULKAN_HPP_NOEXCEPT;
+
+      void copyMemoryToAccelerationStructureKHR( const CopyMemoryToAccelerationStructureInfoKHR & info ) const
+        VULKAN_HPP_NOEXCEPT;
+
+      void writeAccelerationStructuresPropertiesKHR(
+        ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
+        VULKAN_HPP_NAMESPACE::QueryType                                          queryType,
+        VULKAN_HPP_NAMESPACE::QueryPool                                          queryPool,
+        uint32_t                                                                 firstQuery ) const VULKAN_HPP_NOEXCEPT;
+
+      //=== VK_NV_shading_rate_image ===
+
+      void bindShadingRateImageNV( VULKAN_HPP_NAMESPACE::ImageView   imageView,
+                                   VULKAN_HPP_NAMESPACE::ImageLayout imageLayout ) const VULKAN_HPP_NOEXCEPT;
+
+      void setViewportShadingRatePaletteNV( uint32_t firstViewport,
+                                            ArrayProxy<const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV> const &
+                                              shadingRatePalettes ) const VULKAN_HPP_NOEXCEPT;
+
+      void setCoarseSampleOrderNV( VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV sampleOrderType,
+                                   ArrayProxy<const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV> const &
+                                     customSampleOrders ) const VULKAN_HPP_NOEXCEPT;
+
+      //=== VK_NV_ray_tracing ===
+
+      void buildAccelerationStructureNV( const AccelerationStructureInfoNV &           info,
+                                         VULKAN_HPP_NAMESPACE::Buffer                  instanceData,
+                                         VULKAN_HPP_NAMESPACE::DeviceSize              instanceOffset,
+                                         VULKAN_HPP_NAMESPACE::Bool32                  update,
+                                         VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst,
+                                         VULKAN_HPP_NAMESPACE::AccelerationStructureNV src,
+                                         VULKAN_HPP_NAMESPACE::Buffer                  scratch,
+                                         VULKAN_HPP_NAMESPACE::DeviceSize scratchOffset ) const VULKAN_HPP_NOEXCEPT;
+
+      void copyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV          dst,
+                                        VULKAN_HPP_NAMESPACE::AccelerationStructureNV          src,
+                                        VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR mode ) const
+        VULKAN_HPP_NOEXCEPT;
 
       void traceRaysNV( VULKAN_HPP_NAMESPACE::Buffer     raygenShaderBindingTableBuffer,
                         VULKAN_HPP_NAMESPACE::DeviceSize raygenShaderBindingOffset,
@@ -3659,56 +3701,224 @@ namespace VULKAN_HPP_NAMESPACE
                         uint32_t                         height,
                         uint32_t                         depth ) const VULKAN_HPP_NOEXCEPT;
 
-      template <typename T>
-      void updateBuffer( VULKAN_HPP_NAMESPACE::Buffer     dstBuffer,
-                         VULKAN_HPP_NAMESPACE::DeviceSize dstOffset,
-                         ArrayProxy<const T> const &      data ) const VULKAN_HPP_NOEXCEPT;
-
-      void waitEvents( ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const &               events,
-                       VULKAN_HPP_NAMESPACE::PipelineStageFlags                            srcStageMask,
-                       VULKAN_HPP_NAMESPACE::PipelineStageFlags                            dstStageMask,
-                       ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const &       memoryBarriers,
-                       ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const & bufferMemoryBarriers,
-                       ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const &  imageMemoryBarriers ) const
-        VULKAN_HPP_NOEXCEPT;
-
-      void waitEvents2KHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const &             events,
-                           ArrayProxy<const VULKAN_HPP_NAMESPACE::DependencyInfoKHR> const & dependencyInfos ) const
-        VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
-
-      void writeAccelerationStructuresPropertiesKHR(
-        ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
-        VULKAN_HPP_NAMESPACE::QueryType                                          queryType,
-        VULKAN_HPP_NAMESPACE::QueryPool                                          queryPool,
-        uint32_t                                                                 firstQuery ) const VULKAN_HPP_NOEXCEPT;
-
       void writeAccelerationStructuresPropertiesNV(
         ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureNV> const & accelerationStructures,
         VULKAN_HPP_NAMESPACE::QueryType                                         queryType,
         VULKAN_HPP_NAMESPACE::QueryPool                                         queryPool,
         uint32_t                                                                firstQuery ) const VULKAN_HPP_NOEXCEPT;
 
-      void writeBufferMarker2AMD( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR stage,
-                                  VULKAN_HPP_NAMESPACE::Buffer                 dstBuffer,
-                                  VULKAN_HPP_NAMESPACE::DeviceSize             dstOffset,
-                                  uint32_t                                     marker ) const VULKAN_HPP_NOEXCEPT;
+      //=== VK_KHR_draw_indirect_count ===
+
+      void drawIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer     buffer,
+                                 VULKAN_HPP_NAMESPACE::DeviceSize offset,
+                                 VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
+                                 VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
+                                 uint32_t                         maxDrawCount,
+                                 uint32_t                         stride ) const VULKAN_HPP_NOEXCEPT;
+
+      void drawIndexedIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer     buffer,
+                                        VULKAN_HPP_NAMESPACE::DeviceSize offset,
+                                        VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
+                                        VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
+                                        uint32_t                         maxDrawCount,
+                                        uint32_t                         stride ) const VULKAN_HPP_NOEXCEPT;
+
+      //=== VK_AMD_buffer_marker ===
 
       void writeBufferMarkerAMD( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage,
                                  VULKAN_HPP_NAMESPACE::Buffer                dstBuffer,
                                  VULKAN_HPP_NAMESPACE::DeviceSize            dstOffset,
                                  uint32_t                                    marker ) const VULKAN_HPP_NOEXCEPT;
 
-      void writeTimestamp( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage,
-                           VULKAN_HPP_NAMESPACE::QueryPool             queryPool,
-                           uint32_t                                    query ) const VULKAN_HPP_NOEXCEPT;
+      //=== VK_NV_mesh_shader ===
+
+      void drawMeshTasksNV( uint32_t taskCount, uint32_t firstTask ) const VULKAN_HPP_NOEXCEPT;
+
+      void drawMeshTasksIndirectNV( VULKAN_HPP_NAMESPACE::Buffer     buffer,
+                                    VULKAN_HPP_NAMESPACE::DeviceSize offset,
+                                    uint32_t                         drawCount,
+                                    uint32_t                         stride ) const VULKAN_HPP_NOEXCEPT;
+
+      void drawMeshTasksIndirectCountNV( VULKAN_HPP_NAMESPACE::Buffer     buffer,
+                                         VULKAN_HPP_NAMESPACE::DeviceSize offset,
+                                         VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
+                                         VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
+                                         uint32_t                         maxDrawCount,
+                                         uint32_t                         stride ) const VULKAN_HPP_NOEXCEPT;
+
+      //=== VK_NV_scissor_exclusive ===
+
+      void setExclusiveScissorNV( uint32_t                                               firstExclusiveScissor,
+                                  ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & exclusiveScissors ) const
+        VULKAN_HPP_NOEXCEPT;
+
+      //=== VK_NV_device_diagnostic_checkpoints ===
+
+      void setCheckpointNV( const void * pCheckpointMarker ) const VULKAN_HPP_NOEXCEPT;
+
+      //=== VK_INTEL_performance_query ===
+
+      void setPerformanceMarkerINTEL( const PerformanceMarkerInfoINTEL & markerInfo ) const;
+
+      void setPerformanceStreamMarkerINTEL( const PerformanceStreamMarkerInfoINTEL & markerInfo ) const;
+
+      void setPerformanceOverrideINTEL( const PerformanceOverrideInfoINTEL & overrideInfo ) const;
+
+      //=== VK_KHR_fragment_shading_rate ===
+
+      void setFragmentShadingRateKHR(
+        const Extent2D &                                             fragmentSize,
+        const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2] ) const VULKAN_HPP_NOEXCEPT;
+
+      //=== VK_EXT_line_rasterization ===
+
+      void setLineStippleEXT( uint32_t lineStippleFactor, uint16_t lineStipplePattern ) const VULKAN_HPP_NOEXCEPT;
+
+      //=== VK_EXT_extended_dynamic_state ===
+
+      void setCullModeEXT( VULKAN_HPP_NAMESPACE::CullModeFlags cullMode VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const
+        VULKAN_HPP_NOEXCEPT;
+
+      void setFrontFaceEXT( VULKAN_HPP_NAMESPACE::FrontFace frontFace ) const VULKAN_HPP_NOEXCEPT;
+
+      void
+        setPrimitiveTopologyEXT( VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology ) const VULKAN_HPP_NOEXCEPT;
+
+      void setViewportWithCountEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports ) const
+        VULKAN_HPP_NOEXCEPT;
+
+      void setScissorWithCountEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors ) const
+        VULKAN_HPP_NOEXCEPT;
+
+      void bindVertexBuffers2EXT(
+        uint32_t                                                         firstBinding,
+        ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &           buffers,
+        ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const &       offsets,
+        ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+        ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & strides
+          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
+
+      void setDepthTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable ) const VULKAN_HPP_NOEXCEPT;
+
+      void setDepthWriteEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable ) const VULKAN_HPP_NOEXCEPT;
+
+      void setDepthCompareOpEXT( VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp ) const VULKAN_HPP_NOEXCEPT;
+
+      void setDepthBoundsTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable ) const VULKAN_HPP_NOEXCEPT;
+
+      void setStencilTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable ) const VULKAN_HPP_NOEXCEPT;
+
+      void setStencilOpEXT( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
+                            VULKAN_HPP_NAMESPACE::StencilOp        failOp,
+                            VULKAN_HPP_NAMESPACE::StencilOp        passOp,
+                            VULKAN_HPP_NAMESPACE::StencilOp        depthFailOp,
+                            VULKAN_HPP_NAMESPACE::CompareOp        compareOp ) const VULKAN_HPP_NOEXCEPT;
+
+      //=== VK_NV_device_generated_commands ===
+
+      void preprocessGeneratedCommandsNV( const GeneratedCommandsInfoNV & generatedCommandsInfo ) const
+        VULKAN_HPP_NOEXCEPT;
+
+      void
+        executeGeneratedCommandsNV( VULKAN_HPP_NAMESPACE::Bool32    isPreprocessed,
+                                    const GeneratedCommandsInfoNV & generatedCommandsInfo ) const VULKAN_HPP_NOEXCEPT;
+
+      void bindPipelineShaderGroupNV( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
+                                      VULKAN_HPP_NAMESPACE::Pipeline          pipeline,
+                                      uint32_t                                groupIndex ) const VULKAN_HPP_NOEXCEPT;
+
+#  if defined( VK_ENABLE_BETA_EXTENSIONS )
+      //=== VK_KHR_video_encode_queue ===
+
+      void encodeVideoKHR( const VideoEncodeInfoKHR & encodeInfo ) const VULKAN_HPP_NOEXCEPT;
+#  endif /*VK_ENABLE_BETA_EXTENSIONS*/
+
+      //=== VK_KHR_synchronization2 ===
+
+      void setEvent2KHR( VULKAN_HPP_NAMESPACE::Event event,
+                         const DependencyInfoKHR &   dependencyInfo ) const VULKAN_HPP_NOEXCEPT;
+
+      void resetEvent2KHR( VULKAN_HPP_NAMESPACE::Event                  event,
+                           VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR stageMask ) const VULKAN_HPP_NOEXCEPT;
+
+      void waitEvents2KHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const &             events,
+                           ArrayProxy<const VULKAN_HPP_NAMESPACE::DependencyInfoKHR> const & dependencyInfos ) const
+        VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
+
+      void pipelineBarrier2KHR( const DependencyInfoKHR & dependencyInfo ) const VULKAN_HPP_NOEXCEPT;
 
       void writeTimestamp2KHR( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR stage,
                                VULKAN_HPP_NAMESPACE::QueryPool              queryPool,
                                uint32_t                                     query ) const VULKAN_HPP_NOEXCEPT;
 
-      void end() const;
+      void writeBufferMarker2AMD( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR stage,
+                                  VULKAN_HPP_NAMESPACE::Buffer                 dstBuffer,
+                                  VULKAN_HPP_NAMESPACE::DeviceSize             dstOffset,
+                                  uint32_t                                     marker ) const VULKAN_HPP_NOEXCEPT;
 
-      void reset( VULKAN_HPP_NAMESPACE::CommandBufferResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const;
+      //=== VK_NV_fragment_shading_rate_enums ===
+
+      void setFragmentShadingRateEnumNV(
+        VULKAN_HPP_NAMESPACE::FragmentShadingRateNV                  shadingRate,
+        const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2] ) const VULKAN_HPP_NOEXCEPT;
+
+      //=== VK_KHR_copy_commands2 ===
+
+      void copyBuffer2KHR( const CopyBufferInfo2KHR & copyBufferInfo ) const VULKAN_HPP_NOEXCEPT;
+
+      void copyImage2KHR( const CopyImageInfo2KHR & copyImageInfo ) const VULKAN_HPP_NOEXCEPT;
+
+      void copyBufferToImage2KHR( const CopyBufferToImageInfo2KHR & copyBufferToImageInfo ) const VULKAN_HPP_NOEXCEPT;
+
+      void copyImageToBuffer2KHR( const CopyImageToBufferInfo2KHR & copyImageToBufferInfo ) const VULKAN_HPP_NOEXCEPT;
+
+      void blitImage2KHR( const BlitImageInfo2KHR & blitImageInfo ) const VULKAN_HPP_NOEXCEPT;
+
+      void resolveImage2KHR( const ResolveImageInfo2KHR & resolveImageInfo ) const VULKAN_HPP_NOEXCEPT;
+
+      //=== VK_KHR_ray_tracing_pipeline ===
+
+      void traceRaysKHR( const StridedDeviceAddressRegionKHR & raygenShaderBindingTable,
+                         const StridedDeviceAddressRegionKHR & missShaderBindingTable,
+                         const StridedDeviceAddressRegionKHR & hitShaderBindingTable,
+                         const StridedDeviceAddressRegionKHR & callableShaderBindingTable,
+                         uint32_t                              width,
+                         uint32_t                              height,
+                         uint32_t                              depth ) const VULKAN_HPP_NOEXCEPT;
+
+      void traceRaysIndirectKHR( const StridedDeviceAddressRegionKHR & raygenShaderBindingTable,
+                                 const StridedDeviceAddressRegionKHR & missShaderBindingTable,
+                                 const StridedDeviceAddressRegionKHR & hitShaderBindingTable,
+                                 const StridedDeviceAddressRegionKHR & callableShaderBindingTable,
+                                 VULKAN_HPP_NAMESPACE::DeviceAddress indirectDeviceAddress ) const VULKAN_HPP_NOEXCEPT;
+
+      void setRayTracingPipelineStackSizeKHR( uint32_t pipelineStackSize ) const VULKAN_HPP_NOEXCEPT;
+
+      //=== VK_EXT_vertex_input_dynamic_state ===
+
+      void setVertexInputEXT(
+        ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT> const & vertexBindingDescriptions,
+        ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT> const &
+          vertexAttributeDescriptions ) const VULKAN_HPP_NOEXCEPT;
+
+      //=== VK_EXT_extended_dynamic_state2 ===
+
+      void setPatchControlPointsEXT( uint32_t patchControlPoints ) const VULKAN_HPP_NOEXCEPT;
+
+      void
+        setRasterizerDiscardEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable ) const VULKAN_HPP_NOEXCEPT;
+
+      void setDepthBiasEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable ) const VULKAN_HPP_NOEXCEPT;
+
+      void setLogicOpEXT( VULKAN_HPP_NAMESPACE::LogicOp logicOp ) const VULKAN_HPP_NOEXCEPT;
+
+      void
+        setPrimitiveRestartEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable ) const VULKAN_HPP_NOEXCEPT;
+
+      //=== VK_EXT_color_write_enable ===
+
+      void setColorWriteEnableEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & colorWriteEnables ) const
+        VULKAN_HPP_NOEXCEPT;
 
       VULKAN_HPP_NAMESPACE::CommandBuffer const & operator*() const VULKAN_HPP_NOEXCEPT
       {
@@ -4204,12 +4414,14 @@ namespace VULKAN_HPP_NAMESPACE
         return *this;
       }
 
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result join() const;
+      //=== VK_KHR_deferred_host_operations ===
 
       VULKAN_HPP_NODISCARD uint32_t getMaxConcurrency() const VULKAN_HPP_NOEXCEPT;
 
       VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getResult() const VULKAN_HPP_NOEXCEPT;
 
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result join() const;
+
       VULKAN_HPP_NAMESPACE::DeferredOperationKHR const & operator*() const VULKAN_HPP_NOEXCEPT
       {
         return m_deferredOperationKHR;
@@ -4301,6 +4513,8 @@ namespace VULKAN_HPP_NAMESPACE
         return *this;
       }
 
+      //=== VK_VERSION_1_0 ===
+
       void reset( VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const
         VULKAN_HPP_NOEXCEPT;
 
@@ -4383,9 +4597,13 @@ namespace VULKAN_HPP_NAMESPACE
         return *this;
       }
 
+      //=== VK_VERSION_1_1 ===
+
       void updateWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
                                const void *                                   pData ) const VULKAN_HPP_NOEXCEPT;
 
+      //=== VK_KHR_descriptor_update_template ===
+
       void updateWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
                                   const void *                                   pData ) const VULKAN_HPP_NOEXCEPT;
 
@@ -4702,12 +4920,7 @@ namespace VULKAN_HPP_NAMESPACE
         return *this;
       }
 
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceSize getCommitment() const VULKAN_HPP_NOEXCEPT;
-
-#  if defined( VK_USE_PLATFORM_WIN32_KHR )
-      VULKAN_HPP_NODISCARD HANDLE
-        getMemoryWin32HandleNV( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleType ) const;
-#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
+      //=== VK_VERSION_1_0 ===
 
       VULKAN_HPP_NODISCARD void *
         mapMemory( VULKAN_HPP_NAMESPACE::DeviceSize           offset,
@@ -4716,6 +4929,15 @@ namespace VULKAN_HPP_NAMESPACE
 
       void unmapMemory() const VULKAN_HPP_NOEXCEPT;
 
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceSize getCommitment() const VULKAN_HPP_NOEXCEPT;
+
+#  if defined( VK_USE_PLATFORM_WIN32_KHR )
+      //=== VK_NV_external_memory_win32 ===
+
+      VULKAN_HPP_NODISCARD HANDLE
+        getMemoryWin32HandleNV( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleType ) const;
+#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
       VULKAN_HPP_NAMESPACE::DeviceMemory const & operator*() const VULKAN_HPP_NOEXCEPT
       {
         return m_deviceMemory;
@@ -4819,13 +5041,19 @@ namespace VULKAN_HPP_NAMESPACE
         return *this;
       }
 
-#  if defined( VK_USE_PLATFORM_WIN32_KHR )
-      void acquireWinrtNV() const;
-#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
+      //=== VK_KHR_display ===
+
+      VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR> getModeProperties() const;
+
+      //=== VK_KHR_get_display_properties2 ===
 
       VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR> getModeProperties2() const;
 
-      VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR> getModeProperties() const;
+#  if defined( VK_USE_PLATFORM_WIN32_KHR )
+      //=== VK_NV_acquire_winrt_display ===
+
+      void acquireWinrtNV() const;
+#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
       VULKAN_HPP_NAMESPACE::DisplayKHR const & operator*() const VULKAN_HPP_NOEXCEPT
       {
@@ -4943,6 +5171,8 @@ namespace VULKAN_HPP_NAMESPACE
         return *this;
       }
 
+      //=== VK_KHR_display ===
+
       VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR
                            getDisplayPlaneCapabilities( uint32_t planeIndex ) const;
 
@@ -5032,12 +5262,14 @@ namespace VULKAN_HPP_NAMESPACE
         return *this;
       }
 
+      //=== VK_VERSION_1_0 ===
+
       VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getStatus() const;
 
-      void reset() const;
-
       void set() const;
 
+      void reset() const;
+
       VULKAN_HPP_NAMESPACE::Event const & operator*() const VULKAN_HPP_NOEXCEPT
       {
         return m_event;
@@ -5166,6 +5398,8 @@ namespace VULKAN_HPP_NAMESPACE
         return *this;
       }
 
+      //=== VK_VERSION_1_0 ===
+
       VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getStatus() const;
 
       VULKAN_HPP_NAMESPACE::Fence const & operator*() const VULKAN_HPP_NOEXCEPT
@@ -5342,10 +5576,9 @@ namespace VULKAN_HPP_NAMESPACE
         return *this;
       }
 
-      void bindMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset ) const;
+      //=== VK_VERSION_1_0 ===
 
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT
-                           getDrmFormatModifierPropertiesEXT() const;
+      void bindMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset ) const;
 
       VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements getMemoryRequirements() const VULKAN_HPP_NOEXCEPT;
 
@@ -5355,6 +5588,11 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SubresourceLayout
                            getSubresourceLayout( const ImageSubresource & subresource ) const VULKAN_HPP_NOEXCEPT;
 
+      //=== VK_EXT_image_drm_format_modifier ===
+
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT
+                           getDrmFormatModifierPropertiesEXT() const;
+
       VULKAN_HPP_NAMESPACE::Image const & operator*() const VULKAN_HPP_NOEXCEPT
       {
         return m_image;
@@ -5442,6 +5680,8 @@ namespace VULKAN_HPP_NAMESPACE
         return *this;
       }
 
+      //=== VK_NVX_image_view_handle ===
+
       VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX getAddressNVX() const;
 
       VULKAN_HPP_NAMESPACE::ImageView const & operator*() const VULKAN_HPP_NOEXCEPT
@@ -5711,6 +5951,8 @@ namespace VULKAN_HPP_NAMESPACE
         return *this;
       }
 
+      //=== VK_VERSION_1_0 ===
+
       VULKAN_HPP_NODISCARD std::vector<uint8_t> getData() const;
 
       void merge( ArrayProxy<const VULKAN_HPP_NAMESPACE::PipelineCache> const & srcCaches ) const;
@@ -5903,8 +6145,32 @@ namespace VULKAN_HPP_NAMESPACE
         return *this;
       }
 
+      //=== VK_AMD_shader_info ===
+
+      VULKAN_HPP_NODISCARD std::vector<uint8_t>
+                           getShaderInfoAMD( VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage,
+                                             VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD   infoType ) const;
+
+      //=== VK_NV_ray_tracing ===
+
+      template <typename T>
+      VULKAN_HPP_NODISCARD std::vector<T>
+        getRayTracingShaderGroupHandlesNV( uint32_t firstGroup, uint32_t groupCount, size_t dataSize ) const;
+
+      template <typename T>
+      VULKAN_HPP_NODISCARD T getRayTracingShaderGroupHandleNV( uint32_t firstGroup, uint32_t groupCount ) const;
+
       void compileDeferredNV( uint32_t shader ) const;
 
+      //=== VK_KHR_ray_tracing_pipeline ===
+
+      template <typename T>
+      VULKAN_HPP_NODISCARD std::vector<T>
+        getRayTracingShaderGroupHandlesKHR( uint32_t firstGroup, uint32_t groupCount, size_t dataSize ) const;
+
+      template <typename T>
+      VULKAN_HPP_NODISCARD T getRayTracingShaderGroupHandleKHR( uint32_t firstGroup, uint32_t groupCount ) const;
+
       template <typename T>
       VULKAN_HPP_NODISCARD std::vector<T> getRayTracingCaptureReplayShaderGroupHandlesKHR( uint32_t firstGroup,
                                                                                            uint32_t groupCount,
@@ -5914,27 +6180,9 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NODISCARD T getRayTracingCaptureReplayShaderGroupHandleKHR( uint32_t firstGroup,
                                                                              uint32_t groupCount ) const;
 
-      template <typename T>
-      VULKAN_HPP_NODISCARD std::vector<T>
-        getRayTracingShaderGroupHandlesKHR( uint32_t firstGroup, uint32_t groupCount, size_t dataSize ) const;
-
-      template <typename T>
-      VULKAN_HPP_NODISCARD T getRayTracingShaderGroupHandleKHR( uint32_t firstGroup, uint32_t groupCount ) const;
-
-      template <typename T>
-      VULKAN_HPP_NODISCARD std::vector<T>
-        getRayTracingShaderGroupHandlesNV( uint32_t firstGroup, uint32_t groupCount, size_t dataSize ) const;
-
-      template <typename T>
-      VULKAN_HPP_NODISCARD T getRayTracingShaderGroupHandleNV( uint32_t firstGroup, uint32_t groupCount ) const;
-
       VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceSize getRayTracingShaderGroupStackSizeKHR(
         uint32_t group, VULKAN_HPP_NAMESPACE::ShaderGroupShaderKHR groupShader ) const VULKAN_HPP_NOEXCEPT;
 
-      VULKAN_HPP_NODISCARD std::vector<uint8_t>
-                           getShaderInfoAMD( VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage,
-                                             VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD   infoType ) const;
-
       VULKAN_HPP_NAMESPACE::Pipeline const & operator*() const VULKAN_HPP_NOEXCEPT
       {
         return m_pipeline;
@@ -6380,6 +6628,8 @@ namespace VULKAN_HPP_NAMESPACE
         return *this;
       }
 
+      //=== VK_VERSION_1_0 ===
+
       template <typename T>
       VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::Result, std::vector<T>>
                            getResults( uint32_t                                     firstQuery,
@@ -6395,8 +6645,12 @@ namespace VULKAN_HPP_NAMESPACE
                                       VULKAN_HPP_NAMESPACE::DeviceSize             stride,
                                       VULKAN_HPP_NAMESPACE::QueryResultFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const;
 
+      //=== VK_VERSION_1_2 ===
+
       void reset( uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT;
 
+      //=== VK_EXT_host_query_reset ===
+
       void resetEXT( uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT;
 
       VULKAN_HPP_NAMESPACE::QueryPool const & operator*() const VULKAN_HPP_NOEXCEPT
@@ -6466,32 +6720,44 @@ namespace VULKAN_HPP_NAMESPACE
         return *this;
       }
 
-      VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointData2NV>
-                           getCheckpointData2NV() const VULKAN_HPP_NOEXCEPT;
+      //=== VK_VERSION_1_0 ===
 
-      VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointDataNV>
-                           getCheckpointDataNV() const VULKAN_HPP_NOEXCEPT;
+      void submit( ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo> const & submits,
+                   VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const;
 
-      void beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT;
+      void waitIdle() const;
 
       void bindSparse( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindSparseInfo> const & bindInfo,
                        VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const;
 
+      //=== VK_KHR_swapchain ===
+
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result presentKHR( const PresentInfoKHR & presentInfo ) const;
+
+      //=== VK_EXT_debug_utils ===
+
+      void beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT;
+
       void endDebugUtilsLabelEXT() const VULKAN_HPP_NOEXCEPT;
 
       void insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT;
 
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result presentKHR( const PresentInfoKHR & presentInfo ) const;
+      //=== VK_NV_device_diagnostic_checkpoints ===
+
+      VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointDataNV>
+                           getCheckpointDataNV() const VULKAN_HPP_NOEXCEPT;
+
+      //=== VK_INTEL_performance_query ===
 
       void setPerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration ) const;
 
-      void submit( ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo> const & submits,
-                   VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const;
+      //=== VK_KHR_synchronization2 ===
 
       void submit2KHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo2KHR> const & submits,
                        VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const;
 
-      void waitIdle() const;
+      VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointData2NV>
+                           getCheckpointData2NV() const VULKAN_HPP_NOEXCEPT;
 
       VULKAN_HPP_NAMESPACE::Queue const & operator*() const VULKAN_HPP_NOEXCEPT
       {
@@ -6597,6 +6863,8 @@ namespace VULKAN_HPP_NAMESPACE
         return *this;
       }
 
+      //=== VK_VERSION_1_0 ===
+
       VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Extent2D getRenderAreaGranularity() const VULKAN_HPP_NOEXCEPT;
 
       VULKAN_HPP_NAMESPACE::RenderPass const & operator*() const VULKAN_HPP_NOEXCEPT
@@ -6867,8 +7135,12 @@ namespace VULKAN_HPP_NAMESPACE
         return *this;
       }
 
+      //=== VK_VERSION_1_2 ===
+
       VULKAN_HPP_NODISCARD uint64_t getCounterValue() const;
 
+      //=== VK_KHR_timeline_semaphore ===
+
       VULKAN_HPP_NODISCARD uint64_t getCounterValueKHR() const;
 
       VULKAN_HPP_NAMESPACE::Semaphore const & operator*() const VULKAN_HPP_NOEXCEPT
@@ -7450,32 +7722,42 @@ namespace VULKAN_HPP_NAMESPACE
         return *this;
       }
 
-#  if defined( VK_USE_PLATFORM_WIN32_KHR )
-      void acquireFullScreenExclusiveModeEXT() const;
-#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
+      //=== VK_KHR_swapchain ===
+
+      VULKAN_HPP_NODISCARD std::vector<VkImage> getImages() const;
 
       VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::Result, uint32_t>
                            acquireNextImage( uint64_t                                  timeout,
                                              VULKAN_HPP_NAMESPACE::Semaphore semaphore VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
                                              VULKAN_HPP_NAMESPACE::Fence fence         VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const;
 
-      VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE>
-                           getPastPresentationTimingGOOGLE() const;
-
-      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE getRefreshCycleDurationGOOGLE() const;
+      //=== VK_EXT_display_control ===
 
       VULKAN_HPP_NODISCARD uint64_t getCounterEXT( VULKAN_HPP_NAMESPACE::SurfaceCounterFlagBitsEXT counter ) const;
 
-      VULKAN_HPP_NODISCARD std::vector<VkImage> getImages() const;
+      //=== VK_GOOGLE_display_timing ===
+
+      VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE getRefreshCycleDurationGOOGLE() const;
+
+      VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE>
+                           getPastPresentationTimingGOOGLE() const;
+
+      //=== VK_KHR_shared_presentable_image ===
 
       VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getStatus() const;
 
-#  if defined( VK_USE_PLATFORM_WIN32_KHR )
-      void releaseFullScreenExclusiveModeEXT() const;
-#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
+      //=== VK_AMD_display_native_hdr ===
 
       void setLocalDimmingAMD( VULKAN_HPP_NAMESPACE::Bool32 localDimmingEnable ) const VULKAN_HPP_NOEXCEPT;
 
+#  if defined( VK_USE_PLATFORM_WIN32_KHR )
+      //=== VK_EXT_full_screen_exclusive ===
+
+      void acquireFullScreenExclusiveModeEXT() const;
+
+      void releaseFullScreenExclusiveModeEXT() const;
+#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
       VULKAN_HPP_NAMESPACE::SwapchainKHR const & operator*() const VULKAN_HPP_NOEXCEPT
       {
         return m_swapchainKHR;
@@ -7613,10 +7895,12 @@ namespace VULKAN_HPP_NAMESPACE
         return *this;
       }
 
-      VULKAN_HPP_NODISCARD std::vector<uint8_t> getData() const;
+      //=== VK_EXT_validation_cache ===
 
       void merge( ArrayProxy<const VULKAN_HPP_NAMESPACE::ValidationCacheEXT> const & srcCaches ) const;
 
+      VULKAN_HPP_NODISCARD std::vector<uint8_t> getData() const;
+
       VULKAN_HPP_NAMESPACE::ValidationCacheEXT const & operator*() const VULKAN_HPP_NOEXCEPT
       {
         return m_validationCacheEXT;
@@ -7710,14 +7994,12 @@ namespace VULKAN_HPP_NAMESPACE
         return *this;
       }
 
-#    if defined( VK_ENABLE_BETA_EXTENSIONS )
+      //=== VK_KHR_video_queue ===
+
+      VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::VideoGetMemoryPropertiesKHR> getMemoryRequirements() const;
+
       void
         bindMemory( ArrayProxy<const VULKAN_HPP_NAMESPACE::VideoBindMemoryKHR> const & videoSessionBindMemories ) const;
-#    endif /*VK_ENABLE_BETA_EXTENSIONS*/
-
-#    if defined( VK_ENABLE_BETA_EXTENSIONS )
-      VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::VideoGetMemoryPropertiesKHR> getMemoryRequirements() const;
-#    endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
       VULKAN_HPP_NAMESPACE::VideoSessionKHR const & operator*() const VULKAN_HPP_NOEXCEPT
       {
@@ -7735,8 +8017,8 @@ namespace VULKAN_HPP_NAMESPACE
       const VkAllocationCallbacks *                                             m_allocator;
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher;
     };
-
 #  endif /*VK_ENABLE_BETA_EXTENSIONS*/
+
 #  if defined( VK_ENABLE_BETA_EXTENSIONS )
     class VideoSessionParametersKHR
     {
@@ -7815,9 +8097,9 @@ namespace VULKAN_HPP_NAMESPACE
         return *this;
       }
 
-#    if defined( VK_ENABLE_BETA_EXTENSIONS )
+      //=== VK_KHR_video_queue ===
+
       void update( const VideoSessionParametersUpdateInfoKHR & updateInfo ) const;
-#    endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
       VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR const & operator*() const VULKAN_HPP_NOEXCEPT
       {
@@ -7835,9 +8117,104 @@ namespace VULKAN_HPP_NAMESPACE
       const VkAllocationCallbacks *                                             m_allocator;
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher;
     };
-
 #  endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
+    //===========================
+    //=== COMMAND Definitions ===
+    //===========================
+
+    //=== VK_VERSION_1_0 ===
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures
+                                           PhysicalDevice::getFeatures() const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures features;
+      getDispatcher()->vkGetPhysicalDeviceFeatures( static_cast<VkPhysicalDevice>( m_physicalDevice ),
+                                                    reinterpret_cast<VkPhysicalDeviceFeatures *>( &features ) );
+      return features;
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::FormatProperties
+      PhysicalDevice::getFormatProperties( VULKAN_HPP_NAMESPACE::Format format ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_NAMESPACE::FormatProperties formatProperties;
+      getDispatcher()->vkGetPhysicalDeviceFormatProperties(
+        static_cast<VkPhysicalDevice>( m_physicalDevice ),
+        static_cast<VkFormat>( format ),
+        reinterpret_cast<VkFormatProperties *>( &formatProperties ) );
+      return formatProperties;
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ImageFormatProperties
+      PhysicalDevice::getImageFormatProperties( VULKAN_HPP_NAMESPACE::Format           format,
+                                                VULKAN_HPP_NAMESPACE::ImageType        type,
+                                                VULKAN_HPP_NAMESPACE::ImageTiling      tiling,
+                                                VULKAN_HPP_NAMESPACE::ImageUsageFlags  usage,
+                                                VULKAN_HPP_NAMESPACE::ImageCreateFlags flags ) const
+    {
+      VULKAN_HPP_NAMESPACE::ImageFormatProperties imageFormatProperties;
+      VULKAN_HPP_NAMESPACE::Result                result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceImageFormatProperties(
+          static_cast<VkPhysicalDevice>( m_physicalDevice ),
+          static_cast<VkFormat>( format ),
+          static_cast<VkImageType>( type ),
+          static_cast<VkImageTiling>( tiling ),
+          static_cast<VkImageUsageFlags>( usage ),
+          static_cast<VkImageCreateFlags>( flags ),
+          reinterpret_cast<VkImageFormatProperties *>( &imageFormatProperties ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties" );
+      }
+      return imageFormatProperties;
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties
+                                           PhysicalDevice::getProperties() const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties properties;
+      getDispatcher()->vkGetPhysicalDeviceProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ),
+                                                      reinterpret_cast<VkPhysicalDeviceProperties *>( &properties ) );
+      return properties;
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties>
+                                           PhysicalDevice::getQueueFamilyProperties() const VULKAN_HPP_NOEXCEPT
+    {
+      uint32_t queueFamilyPropertyCount;
+      getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties(
+        static_cast<VkPhysicalDevice>( m_physicalDevice ), &queueFamilyPropertyCount, nullptr );
+      std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties> queueFamilyProperties( queueFamilyPropertyCount );
+      getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties(
+        static_cast<VkPhysicalDevice>( m_physicalDevice ),
+        &queueFamilyPropertyCount,
+        reinterpret_cast<VkQueueFamilyProperties *>( queueFamilyProperties.data() ) );
+      VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() );
+      return queueFamilyProperties;
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties
+                                           PhysicalDevice::getMemoryProperties() const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties memoryProperties;
+      getDispatcher()->vkGetPhysicalDeviceMemoryProperties(
+        static_cast<VkPhysicalDevice>( m_physicalDevice ),
+        reinterpret_cast<VkPhysicalDeviceMemoryProperties *>( &memoryProperties ) );
+      return memoryProperties;
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PFN_vkVoidFunction
+      Instance::getProcAddr( const std::string & name ) const VULKAN_HPP_NOEXCEPT
+    {
+      return getDispatcher()->vkGetInstanceProcAddr( static_cast<VkInstance>( m_instance ), name.c_str() );
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PFN_vkVoidFunction
+      Device::getProcAddr( const std::string & name ) const VULKAN_HPP_NOEXCEPT
+    {
+      return getDispatcher()->vkGetDeviceProcAddr( static_cast<VkDevice>( m_device ), name.c_str() );
+    }
+
     VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties>
       Context::enumerateInstanceExtensionProperties( Optional<const std::string> layerName ) const
     {
@@ -7869,174 +8246,6 @@ namespace VULKAN_HPP_NAMESPACE
       return properties;
     }
 
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::LayerProperties>
-                                           Context::enumerateInstanceLayerProperties() const
-    {
-      std::vector<VULKAN_HPP_NAMESPACE::LayerProperties> properties;
-      uint32_t                                           propertyCount;
-      VULKAN_HPP_NAMESPACE::Result                       result;
-      do
-      {
-        result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-          getDispatcher()->vkEnumerateInstanceLayerProperties( &propertyCount, nullptr ) );
-        if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount )
-        {
-          properties.resize( propertyCount );
-          result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkEnumerateInstanceLayerProperties(
-            &propertyCount, reinterpret_cast<VkLayerProperties *>( properties.data() ) ) );
-          VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
-        }
-      } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
-      if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( propertyCount < properties.size() ) )
-      {
-        properties.resize( propertyCount );
-      }
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Context::enumerateInstanceLayerProperties" );
-      }
-      return properties;
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint32_t Context::enumerateInstanceVersion() const
-    {
-      uint32_t                     apiVersion;
-      VULKAN_HPP_NAMESPACE::Result result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkEnumerateInstanceVersion( &apiVersion ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Context::enumerateInstanceVersion" );
-      }
-      return apiVersion;
-    }
-
-    VULKAN_HPP_INLINE void Instance::debugReportMessageEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT      flags,
-                                                            VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType_,
-                                                            uint64_t                                       object,
-                                                            size_t                                         location,
-                                                            int32_t                                        messageCode,
-                                                            const std::string &                            layerPrefix,
-                                                            const std::string & message ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkDebugReportMessageEXT &&
-                         "Function <vkDebugReportMessageEXT> needs extension <VK_EXT_debug_report> enabled!" );
-
-      getDispatcher()->vkDebugReportMessageEXT( static_cast<VkInstance>( m_instance ),
-                                                static_cast<VkDebugReportFlagsEXT>( flags ),
-                                                static_cast<VkDebugReportObjectTypeEXT>( objectType_ ),
-                                                object,
-                                                location,
-                                                messageCode,
-                                                layerPrefix.c_str(),
-                                                message.c_str() );
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>
-                                           Instance::enumeratePhysicalDeviceGroups() const
-    {
-      std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties> physicalDeviceGroupProperties;
-      uint32_t                                                         physicalDeviceGroupCount;
-      VULKAN_HPP_NAMESPACE::Result                                     result;
-      do
-      {
-        result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkEnumeratePhysicalDeviceGroups(
-          static_cast<VkInstance>( m_instance ), &physicalDeviceGroupCount, nullptr ) );
-        if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && physicalDeviceGroupCount )
-        {
-          physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
-          result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkEnumeratePhysicalDeviceGroups(
-            static_cast<VkInstance>( m_instance ),
-            &physicalDeviceGroupCount,
-            reinterpret_cast<VkPhysicalDeviceGroupProperties *>( physicalDeviceGroupProperties.data() ) ) );
-          VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() );
-        }
-      } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
-      if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) &&
-           ( physicalDeviceGroupCount < physicalDeviceGroupProperties.size() ) )
-      {
-        physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
-      }
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDeviceGroups" );
-      }
-      return physicalDeviceGroupProperties;
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>
-                                           Instance::enumeratePhysicalDeviceGroupsKHR() const
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkEnumeratePhysicalDeviceGroupsKHR &&
-        "Function <vkEnumeratePhysicalDeviceGroupsKHR> needs extension <VK_KHR_device_group_creation> enabled!" );
-
-      std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties> physicalDeviceGroupProperties;
-      uint32_t                                                         physicalDeviceGroupCount;
-      VULKAN_HPP_NAMESPACE::Result                                     result;
-      do
-      {
-        result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkEnumeratePhysicalDeviceGroupsKHR(
-          static_cast<VkInstance>( m_instance ), &physicalDeviceGroupCount, nullptr ) );
-        if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && physicalDeviceGroupCount )
-        {
-          physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
-          result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkEnumeratePhysicalDeviceGroupsKHR(
-            static_cast<VkInstance>( m_instance ),
-            &physicalDeviceGroupCount,
-            reinterpret_cast<VkPhysicalDeviceGroupProperties *>( physicalDeviceGroupProperties.data() ) ) );
-          VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() );
-        }
-      } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
-      if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) &&
-           ( physicalDeviceGroupCount < physicalDeviceGroupProperties.size() ) )
-      {
-        physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
-      }
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDeviceGroupsKHR" );
-      }
-      return physicalDeviceGroupProperties;
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PFN_vkVoidFunction
-      Instance::getProcAddr( const std::string & name ) const VULKAN_HPP_NOEXCEPT
-    {
-      return getDispatcher()->vkGetInstanceProcAddr( static_cast<VkInstance>( m_instance ), name.c_str() );
-    }
-
-    VULKAN_HPP_INLINE void Instance::submitDebugUtilsMessageEXT(
-      VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
-      VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT        messageTypes,
-      const DebugUtilsMessengerCallbackDataEXT &                 callbackData ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkSubmitDebugUtilsMessageEXT &&
-                         "Function <vkSubmitDebugUtilsMessageEXT> needs extension <VK_EXT_debug_utils> enabled!" );
-
-      getDispatcher()->vkSubmitDebugUtilsMessageEXT(
-        static_cast<VkInstance>( m_instance ),
-        static_cast<VkDebugUtilsMessageSeverityFlagBitsEXT>( messageSeverity ),
-        static_cast<VkDebugUtilsMessageTypeFlagsEXT>( messageTypes ),
-        reinterpret_cast<const VkDebugUtilsMessengerCallbackDataEXT *>( &callbackData ) );
-    }
-
-#  if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
-    VULKAN_HPP_INLINE void PhysicalDevice::acquireXlibDisplayEXT( Display &                        dpy,
-                                                                  VULKAN_HPP_NAMESPACE::DisplayKHR display ) const
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkAcquireXlibDisplayEXT &&
-                         "Function <vkAcquireXlibDisplayEXT> needs extension <VK_EXT_acquire_xlib_display> enabled!" );
-
-      VULKAN_HPP_NAMESPACE::Result result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkAcquireXlibDisplayEXT(
-          static_cast<VkPhysicalDevice>( m_physicalDevice ), &dpy, static_cast<VkDisplayKHR>( display ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::acquireXlibDisplayEXT" );
-      }
-    }
-#  endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
-
     VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties>
       PhysicalDevice::enumerateDeviceExtensionProperties( Optional<const std::string> layerName ) const
     {
@@ -8073,6 +8282,35 @@ namespace VULKAN_HPP_NAMESPACE
       return properties;
     }
 
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::LayerProperties>
+                                           Context::enumerateInstanceLayerProperties() const
+    {
+      std::vector<VULKAN_HPP_NAMESPACE::LayerProperties> properties;
+      uint32_t                                           propertyCount;
+      VULKAN_HPP_NAMESPACE::Result                       result;
+      do
+      {
+        result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
+          getDispatcher()->vkEnumerateInstanceLayerProperties( &propertyCount, nullptr ) );
+        if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount )
+        {
+          properties.resize( propertyCount );
+          result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkEnumerateInstanceLayerProperties(
+            &propertyCount, reinterpret_cast<VkLayerProperties *>( properties.data() ) ) );
+          VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+        }
+      } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
+      if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( propertyCount < properties.size() ) )
+      {
+        properties.resize( propertyCount );
+      }
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Context::enumerateInstanceLayerProperties" );
+      }
+      return properties;
+    }
+
     VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::LayerProperties>
                                            PhysicalDevice::enumerateDeviceLayerProperties() const
     {
@@ -8104,303 +8342,1354 @@ namespace VULKAN_HPP_NAMESPACE
       return properties;
     }
 
-    VULKAN_HPP_NODISCARD
-      VULKAN_HPP_INLINE std::pair<std::vector<PerformanceCounterKHR>, std::vector<PerformanceCounterDescriptionKHR>>
-      PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex ) const
+    VULKAN_HPP_INLINE void Queue::submit( ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo> const & submits,
+                                          VULKAN_HPP_NAMESPACE::Fence                                fence ) const
     {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR &&
-        "Function <vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR> needs extension <VK_KHR_performance_query> enabled!" );
+      VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
+        getDispatcher()->vkQueueSubmit( static_cast<VkQueue>( m_queue ),
+                                        submits.size(),
+                                        reinterpret_cast<const VkSubmitInfo *>( submits.data() ),
+                                        static_cast<VkFence>( fence ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::submit" );
+      }
+    }
 
-      std::pair<std::vector<PerformanceCounterKHR>, std::vector<PerformanceCounterDescriptionKHR>> data;
-      std::vector<PerformanceCounterKHR> &            counters            = data.first;
-      std::vector<PerformanceCounterDescriptionKHR> & counterDescriptions = data.second;
-      uint32_t                                        counterCount;
-      VULKAN_HPP_NAMESPACE::Result                    result;
+    VULKAN_HPP_INLINE void Queue::waitIdle() const
+    {
+      VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
+        getDispatcher()->vkQueueWaitIdle( static_cast<VkQueue>( m_queue ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::waitIdle" );
+      }
+    }
+
+    VULKAN_HPP_INLINE void Device::waitIdle() const
+    {
+      VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
+        getDispatcher()->vkDeviceWaitIdle( static_cast<VkDevice>( m_device ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::waitIdle" );
+      }
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE void *
+                         DeviceMemory::mapMemory( VULKAN_HPP_NAMESPACE::DeviceSize     offset,
+                               VULKAN_HPP_NAMESPACE::DeviceSize     size,
+                               VULKAN_HPP_NAMESPACE::MemoryMapFlags flags ) const
+    {
+      void *                       pData;
+      VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
+        getDispatcher()->vkMapMemory( static_cast<VkDevice>( m_device ),
+                                      static_cast<VkDeviceMemory>( m_deviceMemory ),
+                                      static_cast<VkDeviceSize>( offset ),
+                                      static_cast<VkDeviceSize>( size ),
+                                      static_cast<VkMemoryMapFlags>( flags ),
+                                      &pData ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::DeviceMemory::mapMemory" );
+      }
+      return pData;
+    }
+
+    VULKAN_HPP_INLINE void DeviceMemory::unmapMemory() const VULKAN_HPP_NOEXCEPT
+    {
+      getDispatcher()->vkUnmapMemory( static_cast<VkDevice>( m_device ),
+                                      static_cast<VkDeviceMemory>( m_deviceMemory ) );
+    }
+
+    VULKAN_HPP_INLINE void Device::flushMappedMemoryRanges(
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges ) const
+    {
+      VULKAN_HPP_NAMESPACE::Result result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkFlushMappedMemoryRanges(
+          static_cast<VkDevice>( m_device ),
+          memoryRanges.size(),
+          reinterpret_cast<const VkMappedMemoryRange *>( memoryRanges.data() ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::flushMappedMemoryRanges" );
+      }
+    }
+
+    VULKAN_HPP_INLINE void Device::invalidateMappedMemoryRanges(
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges ) const
+    {
+      VULKAN_HPP_NAMESPACE::Result result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkInvalidateMappedMemoryRanges(
+          static_cast<VkDevice>( m_device ),
+          memoryRanges.size(),
+          reinterpret_cast<const VkMappedMemoryRange *>( memoryRanges.data() ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::invalidateMappedMemoryRanges" );
+      }
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceSize
+                                           DeviceMemory::getCommitment() const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_NAMESPACE::DeviceSize committedMemoryInBytes;
+      getDispatcher()->vkGetDeviceMemoryCommitment( static_cast<VkDevice>( m_device ),
+                                                    static_cast<VkDeviceMemory>( m_deviceMemory ),
+                                                    reinterpret_cast<VkDeviceSize *>( &committedMemoryInBytes ) );
+      return committedMemoryInBytes;
+    }
+
+    VULKAN_HPP_INLINE void Buffer::bindMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory,
+                                               VULKAN_HPP_NAMESPACE::DeviceSize   memoryOffset ) const
+    {
+      VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
+        getDispatcher()->vkBindBufferMemory( static_cast<VkDevice>( m_device ),
+                                             static_cast<VkBuffer>( m_buffer ),
+                                             static_cast<VkDeviceMemory>( memory ),
+                                             static_cast<VkDeviceSize>( memoryOffset ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Buffer::bindMemory" );
+      }
+    }
+
+    VULKAN_HPP_INLINE void Image::bindMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory,
+                                              VULKAN_HPP_NAMESPACE::DeviceSize   memoryOffset ) const
+    {
+      VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
+        getDispatcher()->vkBindImageMemory( static_cast<VkDevice>( m_device ),
+                                            static_cast<VkImage>( m_image ),
+                                            static_cast<VkDeviceMemory>( memory ),
+                                            static_cast<VkDeviceSize>( memoryOffset ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Image::bindMemory" );
+      }
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements
+                                           Buffer::getMemoryRequirements() const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_NAMESPACE::MemoryRequirements memoryRequirements;
+      getDispatcher()->vkGetBufferMemoryRequirements( static_cast<VkDevice>( m_device ),
+                                                      static_cast<VkBuffer>( m_buffer ),
+                                                      reinterpret_cast<VkMemoryRequirements *>( &memoryRequirements ) );
+      return memoryRequirements;
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements
+                                           Image::getMemoryRequirements() const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_NAMESPACE::MemoryRequirements memoryRequirements;
+      getDispatcher()->vkGetImageMemoryRequirements( static_cast<VkDevice>( m_device ),
+                                                     static_cast<VkImage>( m_image ),
+                                                     reinterpret_cast<VkMemoryRequirements *>( &memoryRequirements ) );
+      return memoryRequirements;
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements>
+                                           Image::getSparseMemoryRequirements() const VULKAN_HPP_NOEXCEPT
+    {
+      uint32_t sparseMemoryRequirementCount;
+      getDispatcher()->vkGetImageSparseMemoryRequirements(
+        static_cast<VkDevice>( m_device ), static_cast<VkImage>( m_image ), &sparseMemoryRequirementCount, nullptr );
+      std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements> sparseMemoryRequirements(
+        sparseMemoryRequirementCount );
+      getDispatcher()->vkGetImageSparseMemoryRequirements(
+        static_cast<VkDevice>( m_device ),
+        static_cast<VkImage>( m_image ),
+        &sparseMemoryRequirementCount,
+        reinterpret_cast<VkSparseImageMemoryRequirements *>( sparseMemoryRequirements.data() ) );
+      VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() );
+      return sparseMemoryRequirements;
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties>
+      PhysicalDevice::getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format              format,
+                                                      VULKAN_HPP_NAMESPACE::ImageType           type,
+                                                      VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,
+                                                      VULKAN_HPP_NAMESPACE::ImageUsageFlags     usage,
+                                                      VULKAN_HPP_NAMESPACE::ImageTiling         tiling ) const
+      VULKAN_HPP_NOEXCEPT
+    {
+      uint32_t propertyCount;
+      getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties(
+        static_cast<VkPhysicalDevice>( m_physicalDevice ),
+        static_cast<VkFormat>( format ),
+        static_cast<VkImageType>( type ),
+        static_cast<VkSampleCountFlagBits>( samples ),
+        static_cast<VkImageUsageFlags>( usage ),
+        static_cast<VkImageTiling>( tiling ),
+        &propertyCount,
+        nullptr );
+      std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties> properties( propertyCount );
+      getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties(
+        static_cast<VkPhysicalDevice>( m_physicalDevice ),
+        static_cast<VkFormat>( format ),
+        static_cast<VkImageType>( type ),
+        static_cast<VkSampleCountFlagBits>( samples ),
+        static_cast<VkImageUsageFlags>( usage ),
+        static_cast<VkImageTiling>( tiling ),
+        &propertyCount,
+        reinterpret_cast<VkSparseImageFormatProperties *>( properties.data() ) );
+      VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+      return properties;
+    }
+
+    VULKAN_HPP_INLINE void Queue::bindSparse( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindSparseInfo> const & bindInfo,
+                                              VULKAN_HPP_NAMESPACE::Fence fence ) const
+    {
+      VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
+        getDispatcher()->vkQueueBindSparse( static_cast<VkQueue>( m_queue ),
+                                            bindInfo.size(),
+                                            reinterpret_cast<const VkBindSparseInfo *>( bindInfo.data() ),
+                                            static_cast<VkFence>( fence ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::bindSparse" );
+      }
+    }
+
+    VULKAN_HPP_INLINE void Device::resetFences( ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences ) const
+    {
+      VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkResetFences(
+        static_cast<VkDevice>( m_device ), fences.size(), reinterpret_cast<const VkFence *>( fences.data() ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::resetFences" );
+      }
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result Fence::getStatus() const
+    {
+      VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
+        getDispatcher()->vkGetFenceStatus( static_cast<VkDevice>( m_device ), static_cast<VkFence>( m_fence ) ) );
+      if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) &&
+           ( result != VULKAN_HPP_NAMESPACE::Result::eNotReady ) )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Fence::getStatus" );
+      }
+      return result;
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result
+      Device::waitForFences( ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences,
+                             VULKAN_HPP_NAMESPACE::Bool32                          waitAll,
+                             uint64_t                                              timeout ) const
+    {
+      VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
+        getDispatcher()->vkWaitForFences( static_cast<VkDevice>( m_device ),
+                                          fences.size(),
+                                          reinterpret_cast<const VkFence *>( fences.data() ),
+                                          static_cast<VkBool32>( waitAll ),
+                                          timeout ) );
+      if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) &&
+           ( result != VULKAN_HPP_NAMESPACE::Result::eTimeout ) )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::waitForFences" );
+      }
+      return result;
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result Event::getStatus() const
+    {
+      VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
+        getDispatcher()->vkGetEventStatus( static_cast<VkDevice>( m_device ), static_cast<VkEvent>( m_event ) ) );
+      if ( ( result != VULKAN_HPP_NAMESPACE::Result::eEventSet ) &&
+           ( result != VULKAN_HPP_NAMESPACE::Result::eEventReset ) )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Event::getStatus" );
+      }
+      return result;
+    }
+
+    VULKAN_HPP_INLINE void Event::set() const
+    {
+      VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
+        getDispatcher()->vkSetEvent( static_cast<VkDevice>( m_device ), static_cast<VkEvent>( m_event ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Event::set" );
+      }
+    }
+
+    VULKAN_HPP_INLINE void Event::reset() const
+    {
+      VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
+        getDispatcher()->vkResetEvent( static_cast<VkDevice>( m_device ), static_cast<VkEvent>( m_event ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Event::reset" );
+      }
+    }
+
+    template <typename T>
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<VULKAN_HPP_NAMESPACE::Result, std::vector<T>>
+                                           QueryPool::getResults( uint32_t                               firstQuery,
+                             uint32_t                               queryCount,
+                             size_t                                 dataSize,
+                             VULKAN_HPP_NAMESPACE::DeviceSize       stride,
+                             VULKAN_HPP_NAMESPACE::QueryResultFlags flags ) const
+    {
+      VULKAN_HPP_ASSERT( dataSize % sizeof( T ) == 0 );
+      std::vector<T> data( dataSize / sizeof( T ) );
+      Result         result =
+        static_cast<Result>( getDispatcher()->vkGetQueryPoolResults( static_cast<VkDevice>( m_device ),
+                                                                     static_cast<VkQueryPool>( m_queryPool ),
+                                                                     firstQuery,
+                                                                     queryCount,
+                                                                     data.size() * sizeof( T ),
+                                                                     reinterpret_cast<void *>( data.data() ),
+                                                                     static_cast<VkDeviceSize>( stride ),
+                                                                     static_cast<VkQueryResultFlags>( flags ) ) );
+      if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) &&
+           ( result != VULKAN_HPP_NAMESPACE::Result::eNotReady ) )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::QueryPool::getResults" );
+      }
+      return std::make_pair( result, data );
+    }
+
+    template <typename T>
+    VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::Result, T>
+                         QueryPool::getResult( uint32_t                               firstQuery,
+                            uint32_t                               queryCount,
+                            VULKAN_HPP_NAMESPACE::DeviceSize       stride,
+                            VULKAN_HPP_NAMESPACE::QueryResultFlags flags ) const
+    {
+      T      data;
+      Result result =
+        static_cast<Result>( getDispatcher()->vkGetQueryPoolResults( static_cast<VkDevice>( m_device ),
+                                                                     static_cast<VkQueryPool>( m_queryPool ),
+                                                                     firstQuery,
+                                                                     queryCount,
+                                                                     sizeof( T ),
+                                                                     reinterpret_cast<void *>( &data ),
+                                                                     static_cast<VkDeviceSize>( stride ),
+                                                                     static_cast<VkQueryResultFlags>( flags ) ) );
+      if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) &&
+           ( result != VULKAN_HPP_NAMESPACE::Result::eNotReady ) )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::QueryPool::getResult" );
+      }
+      return std::make_pair( result, data );
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::SubresourceLayout
+      Image::getSubresourceLayout( const ImageSubresource & subresource ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_NAMESPACE::SubresourceLayout layout;
+      getDispatcher()->vkGetImageSubresourceLayout( static_cast<VkDevice>( m_device ),
+                                                    static_cast<VkImage>( m_image ),
+                                                    reinterpret_cast<const VkImageSubresource *>( &subresource ),
+                                                    reinterpret_cast<VkSubresourceLayout *>( &layout ) );
+      return layout;
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<uint8_t> PipelineCache::getData() const
+    {
+      std::vector<uint8_t>         data;
+      size_t                       dataSize;
+      VULKAN_HPP_NAMESPACE::Result result;
       do
       {
-        result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-          getDispatcher()->vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
-            static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex, &counterCount, nullptr, nullptr ) );
-        if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && counterCount )
+        result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPipelineCacheData(
+          static_cast<VkDevice>( m_device ), static_cast<VkPipelineCache>( m_pipelineCache ), &dataSize, nullptr ) );
+        if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && dataSize )
         {
-          counters.resize( counterCount );
-          counterDescriptions.resize( counterCount );
+          data.resize( dataSize );
           result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-            getDispatcher()->vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
-              static_cast<VkPhysicalDevice>( m_physicalDevice ),
-              queueFamilyIndex,
-              &counterCount,
-              reinterpret_cast<VkPerformanceCounterKHR *>( counters.data() ),
-              reinterpret_cast<VkPerformanceCounterDescriptionKHR *>( counterDescriptions.data() ) ) );
-          VULKAN_HPP_ASSERT( counterCount <= counters.size() );
+            getDispatcher()->vkGetPipelineCacheData( static_cast<VkDevice>( m_device ),
+                                                     static_cast<VkPipelineCache>( m_pipelineCache ),
+                                                     &dataSize,
+                                                     reinterpret_cast<void *>( data.data() ) ) );
+          VULKAN_HPP_ASSERT( dataSize <= data.size() );
         }
       } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
-      if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( counterCount < counters.size() ) )
+      if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( dataSize < data.size() ) )
       {
-        counters.resize( counterCount );
-        counterDescriptions.resize( counterCount );
+        data.resize( dataSize );
       }
       if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
       {
-        throwResultException(
-          result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR" );
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PipelineCache::getData" );
       }
       return data;
     }
 
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR
-      PhysicalDevice::getDisplayPlaneCapabilities2KHR( const DisplayPlaneInfo2KHR & displayPlaneInfo ) const
+    VULKAN_HPP_INLINE void
+      PipelineCache::merge( ArrayProxy<const VULKAN_HPP_NAMESPACE::PipelineCache> const & srcCaches ) const
     {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetDisplayPlaneCapabilities2KHR &&
-        "Function <vkGetDisplayPlaneCapabilities2KHR> needs extension <VK_KHR_get_display_properties2> enabled!" );
-
-      VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR capabilities;
-      VULKAN_HPP_NAMESPACE::Result                       result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetDisplayPlaneCapabilities2KHR(
-          static_cast<VkPhysicalDevice>( m_physicalDevice ),
-          reinterpret_cast<const VkDisplayPlaneInfo2KHR *>( &displayPlaneInfo ),
-          reinterpret_cast<VkDisplayPlaneCapabilities2KHR *>( &capabilities ) ) );
+      VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
+        getDispatcher()->vkMergePipelineCaches( static_cast<VkDevice>( m_device ),
+                                                static_cast<VkPipelineCache>( m_pipelineCache ),
+                                                srcCaches.size(),
+                                                reinterpret_cast<const VkPipelineCache *>( srcCaches.data() ) ) );
       if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
       {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneCapabilities2KHR" );
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PipelineCache::merge" );
       }
-      return capabilities;
     }
 
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::TimeDomainEXT>
-                                           PhysicalDevice::getCalibrateableTimeDomainsEXT() const
+    VULKAN_HPP_INLINE void
+      DescriptorPool::reset( VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags ) const VULKAN_HPP_NOEXCEPT
     {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetPhysicalDeviceCalibrateableTimeDomainsEXT &&
-        "Function <vkGetPhysicalDeviceCalibrateableTimeDomainsEXT> needs extension <VK_EXT_calibrated_timestamps> enabled!" );
+      getDispatcher()->vkResetDescriptorPool( static_cast<VkDevice>( m_device ),
+                                              static_cast<VkDescriptorPool>( m_descriptorPool ),
+                                              static_cast<VkDescriptorPoolResetFlags>( flags ) );
+    }
 
-      std::vector<VULKAN_HPP_NAMESPACE::TimeDomainEXT> timeDomains;
-      uint32_t                                         timeDomainCount;
-      VULKAN_HPP_NAMESPACE::Result                     result;
-      do
-      {
-        result =
-          static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(
-            static_cast<VkPhysicalDevice>( m_physicalDevice ), &timeDomainCount, nullptr ) );
-        if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && timeDomainCount )
-        {
-          timeDomains.resize( timeDomainCount );
-          result =
-            static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(
-              static_cast<VkPhysicalDevice>( m_physicalDevice ),
-              &timeDomainCount,
-              reinterpret_cast<VkTimeDomainEXT *>( timeDomains.data() ) ) );
-          VULKAN_HPP_ASSERT( timeDomainCount <= timeDomains.size() );
-        }
-      } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
-      if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( timeDomainCount < timeDomains.size() ) )
-      {
-        timeDomains.resize( timeDomainCount );
-      }
+    VULKAN_HPP_INLINE void Device::updateDescriptorSets(
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::CopyDescriptorSet> const &  descriptorCopies ) const VULKAN_HPP_NOEXCEPT
+    {
+      getDispatcher()->vkUpdateDescriptorSets(
+        static_cast<VkDevice>( m_device ),
+        descriptorWrites.size(),
+        reinterpret_cast<const VkWriteDescriptorSet *>( descriptorWrites.data() ),
+        descriptorCopies.size(),
+        reinterpret_cast<const VkCopyDescriptorSet *>( descriptorCopies.data() ) );
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Extent2D
+                                           RenderPass::getRenderAreaGranularity() const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_NAMESPACE::Extent2D granularity;
+      getDispatcher()->vkGetRenderAreaGranularity( static_cast<VkDevice>( m_device ),
+                                                   static_cast<VkRenderPass>( m_renderPass ),
+                                                   reinterpret_cast<VkExtent2D *>( &granularity ) );
+      return granularity;
+    }
+
+    VULKAN_HPP_INLINE void CommandPool::reset( VULKAN_HPP_NAMESPACE::CommandPoolResetFlags flags ) const
+    {
+      VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
+        getDispatcher()->vkResetCommandPool( static_cast<VkDevice>( m_device ),
+                                             static_cast<VkCommandPool>( m_commandPool ),
+                                             static_cast<VkCommandPoolResetFlags>( flags ) ) );
       if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
       {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCalibrateableTimeDomainsEXT" );
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::CommandPool::reset" );
       }
-      return timeDomains;
     }
 
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV>
-                                           PhysicalDevice::getCooperativeMatrixPropertiesNV() const
+    VULKAN_HPP_INLINE void CommandBuffer::begin( const CommandBufferBeginInfo & beginInfo ) const
     {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetPhysicalDeviceCooperativeMatrixPropertiesNV &&
-        "Function <vkGetPhysicalDeviceCooperativeMatrixPropertiesNV> needs extension <VK_NV_cooperative_matrix> enabled!" );
+      VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
+        getDispatcher()->vkBeginCommandBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                               reinterpret_cast<const VkCommandBufferBeginInfo *>( &beginInfo ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::begin" );
+      }
+    }
 
-      std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV> properties;
-      uint32_t                                                         propertyCount;
+    VULKAN_HPP_INLINE void CommandBuffer::end() const
+    {
+      VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
+        getDispatcher()->vkEndCommandBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::end" );
+      }
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::reset( VULKAN_HPP_NAMESPACE::CommandBufferResetFlags flags ) const
+    {
+      VULKAN_HPP_NAMESPACE::Result result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkResetCommandBuffer(
+          static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkCommandBufferResetFlags>( flags ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::reset" );
+      }
+    }
+
+    VULKAN_HPP_INLINE void
+      CommandBuffer::bindPipeline( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
+                                   VULKAN_HPP_NAMESPACE::Pipeline          pipeline ) const VULKAN_HPP_NOEXCEPT
+    {
+      getDispatcher()->vkCmdBindPipeline( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                          static_cast<VkPipelineBindPoint>( pipelineBindPoint ),
+                                          static_cast<VkPipeline>( pipeline ) );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::setViewport(
+      uint32_t                                                 firstViewport,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports ) const VULKAN_HPP_NOEXCEPT
+    {
+      getDispatcher()->vkCmdSetViewport( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                         firstViewport,
+                                         viewports.size(),
+                                         reinterpret_cast<const VkViewport *>( viewports.data() ) );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::setScissor(
+      uint32_t firstScissor, ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors ) const VULKAN_HPP_NOEXCEPT
+    {
+      getDispatcher()->vkCmdSetScissor( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                        firstScissor,
+                                        scissors.size(),
+                                        reinterpret_cast<const VkRect2D *>( scissors.data() ) );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::setLineWidth( float lineWidth ) const VULKAN_HPP_NOEXCEPT
+    {
+      getDispatcher()->vkCmdSetLineWidth( static_cast<VkCommandBuffer>( m_commandBuffer ), lineWidth );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::setDepthBias( float depthBiasConstantFactor,
+                                                        float depthBiasClamp,
+                                                        float depthBiasSlopeFactor ) const VULKAN_HPP_NOEXCEPT
+    {
+      getDispatcher()->vkCmdSetDepthBias( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                          depthBiasConstantFactor,
+                                          depthBiasClamp,
+                                          depthBiasSlopeFactor );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::setBlendConstants( const float blendConstants[4] ) const VULKAN_HPP_NOEXCEPT
+    {
+      getDispatcher()->vkCmdSetBlendConstants( static_cast<VkCommandBuffer>( m_commandBuffer ), blendConstants );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::setDepthBounds( float minDepthBounds,
+                                                          float maxDepthBounds ) const VULKAN_HPP_NOEXCEPT
+    {
+      getDispatcher()->vkCmdSetDepthBounds(
+        static_cast<VkCommandBuffer>( m_commandBuffer ), minDepthBounds, maxDepthBounds );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::setStencilCompareMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
+                                                                 uint32_t compareMask ) const VULKAN_HPP_NOEXCEPT
+    {
+      getDispatcher()->vkCmdSetStencilCompareMask(
+        static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkStencilFaceFlags>( faceMask ), compareMask );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::setStencilWriteMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
+                                                               uint32_t writeMask ) const VULKAN_HPP_NOEXCEPT
+    {
+      getDispatcher()->vkCmdSetStencilWriteMask(
+        static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkStencilFaceFlags>( faceMask ), writeMask );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::setStencilReference( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
+                                                               uint32_t reference ) const VULKAN_HPP_NOEXCEPT
+    {
+      getDispatcher()->vkCmdSetStencilReference(
+        static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkStencilFaceFlags>( faceMask ), reference );
+    }
+
+    VULKAN_HPP_INLINE void
+      CommandBuffer::bindDescriptorSets( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
+                                         VULKAN_HPP_NAMESPACE::PipelineLayout    layout,
+                                         uint32_t                                firstSet,
+                                         ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets,
+                                         ArrayProxy<const uint32_t> const & dynamicOffsets ) const VULKAN_HPP_NOEXCEPT
+    {
+      getDispatcher()->vkCmdBindDescriptorSets( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                                static_cast<VkPipelineBindPoint>( pipelineBindPoint ),
+                                                static_cast<VkPipelineLayout>( layout ),
+                                                firstSet,
+                                                descriptorSets.size(),
+                                                reinterpret_cast<const VkDescriptorSet *>( descriptorSets.data() ),
+                                                dynamicOffsets.size(),
+                                                dynamicOffsets.data() );
+    }
+
+    VULKAN_HPP_INLINE void
+      CommandBuffer::bindIndexBuffer( VULKAN_HPP_NAMESPACE::Buffer     buffer,
+                                      VULKAN_HPP_NAMESPACE::DeviceSize offset,
+                                      VULKAN_HPP_NAMESPACE::IndexType  indexType ) const VULKAN_HPP_NOEXCEPT
+    {
+      getDispatcher()->vkCmdBindIndexBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                             static_cast<VkBuffer>( buffer ),
+                                             static_cast<VkDeviceSize>( offset ),
+                                             static_cast<VkIndexType>( indexType ) );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers(
+      uint32_t                                                   firstBinding,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &     buffers,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
+    {
+#  ifdef VULKAN_HPP_NO_EXCEPTIONS
+      VULKAN_HPP_ASSERT( buffers.size() == offsets.size() );
+#  else
+      if ( buffers.size() != offsets.size() )
+      {
+        throw LogicError( VULKAN_HPP_NAMESPACE_STRING
+                          "::CommandBuffer::bindVertexBuffers: buffers.size() != offsets.size()" );
+      }
+#  endif /*VULKAN_HPP_NO_EXCEPTIONS*/
+
+      getDispatcher()->vkCmdBindVertexBuffers( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                               firstBinding,
+                                               buffers.size(),
+                                               reinterpret_cast<const VkBuffer *>( buffers.data() ),
+                                               reinterpret_cast<const VkDeviceSize *>( offsets.data() ) );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::draw( uint32_t vertexCount,
+                                                uint32_t instanceCount,
+                                                uint32_t firstVertex,
+                                                uint32_t firstInstance ) const VULKAN_HPP_NOEXCEPT
+    {
+      getDispatcher()->vkCmdDraw(
+        static_cast<VkCommandBuffer>( m_commandBuffer ), vertexCount, instanceCount, firstVertex, firstInstance );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::drawIndexed( uint32_t indexCount,
+                                                       uint32_t instanceCount,
+                                                       uint32_t firstIndex,
+                                                       int32_t  vertexOffset,
+                                                       uint32_t firstInstance ) const VULKAN_HPP_NOEXCEPT
+    {
+      getDispatcher()->vkCmdDrawIndexed( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                         indexCount,
+                                         instanceCount,
+                                         firstIndex,
+                                         vertexOffset,
+                                         firstInstance );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::drawIndirect( VULKAN_HPP_NAMESPACE::Buffer     buffer,
+                                                        VULKAN_HPP_NAMESPACE::DeviceSize offset,
+                                                        uint32_t                         drawCount,
+                                                        uint32_t stride ) const VULKAN_HPP_NOEXCEPT
+    {
+      getDispatcher()->vkCmdDrawIndirect( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                          static_cast<VkBuffer>( buffer ),
+                                          static_cast<VkDeviceSize>( offset ),
+                                          drawCount,
+                                          stride );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirect( VULKAN_HPP_NAMESPACE::Buffer     buffer,
+                                                               VULKAN_HPP_NAMESPACE::DeviceSize offset,
+                                                               uint32_t                         drawCount,
+                                                               uint32_t stride ) const VULKAN_HPP_NOEXCEPT
+    {
+      getDispatcher()->vkCmdDrawIndexedIndirect( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                                 static_cast<VkBuffer>( buffer ),
+                                                 static_cast<VkDeviceSize>( offset ),
+                                                 drawCount,
+                                                 stride );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::dispatch( uint32_t groupCountX,
+                                                    uint32_t groupCountY,
+                                                    uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT
+    {
+      getDispatcher()->vkCmdDispatch(
+        static_cast<VkCommandBuffer>( m_commandBuffer ), groupCountX, groupCountY, groupCountZ );
+    }
+
+    VULKAN_HPP_INLINE void
+      CommandBuffer::dispatchIndirect( VULKAN_HPP_NAMESPACE::Buffer     buffer,
+                                       VULKAN_HPP_NAMESPACE::DeviceSize offset ) const VULKAN_HPP_NOEXCEPT
+    {
+      getDispatcher()->vkCmdDispatchIndirect( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                              static_cast<VkBuffer>( buffer ),
+                                              static_cast<VkDeviceSize>( offset ) );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::copyBuffer(
+      VULKAN_HPP_NAMESPACE::Buffer                               srcBuffer,
+      VULKAN_HPP_NAMESPACE::Buffer                               dstBuffer,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferCopy> const & regions ) const VULKAN_HPP_NOEXCEPT
+    {
+      getDispatcher()->vkCmdCopyBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                        static_cast<VkBuffer>( srcBuffer ),
+                                        static_cast<VkBuffer>( dstBuffer ),
+                                        regions.size(),
+                                        reinterpret_cast<const VkBufferCopy *>( regions.data() ) );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::copyImage(
+      VULKAN_HPP_NAMESPACE::Image                               srcImage,
+      VULKAN_HPP_NAMESPACE::ImageLayout                         srcImageLayout,
+      VULKAN_HPP_NAMESPACE::Image                               dstImage,
+      VULKAN_HPP_NAMESPACE::ImageLayout                         dstImageLayout,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageCopy> const & regions ) const VULKAN_HPP_NOEXCEPT
+    {
+      getDispatcher()->vkCmdCopyImage( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                       static_cast<VkImage>( srcImage ),
+                                       static_cast<VkImageLayout>( srcImageLayout ),
+                                       static_cast<VkImage>( dstImage ),
+                                       static_cast<VkImageLayout>( dstImageLayout ),
+                                       regions.size(),
+                                       reinterpret_cast<const VkImageCopy *>( regions.data() ) );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::blitImage( VULKAN_HPP_NAMESPACE::Image       srcImage,
+                                                     VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout,
+                                                     VULKAN_HPP_NAMESPACE::Image       dstImage,
+                                                     VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,
+                                                     ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageBlit> const & regions,
+                                                     VULKAN_HPP_NAMESPACE::Filter filter ) const VULKAN_HPP_NOEXCEPT
+    {
+      getDispatcher()->vkCmdBlitImage( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                       static_cast<VkImage>( srcImage ),
+                                       static_cast<VkImageLayout>( srcImageLayout ),
+                                       static_cast<VkImage>( dstImage ),
+                                       static_cast<VkImageLayout>( dstImageLayout ),
+                                       regions.size(),
+                                       reinterpret_cast<const VkImageBlit *>( regions.data() ),
+                                       static_cast<VkFilter>( filter ) );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage(
+      VULKAN_HPP_NAMESPACE::Buffer                                    srcBuffer,
+      VULKAN_HPP_NAMESPACE::Image                                     dstImage,
+      VULKAN_HPP_NAMESPACE::ImageLayout                               dstImageLayout,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions ) const VULKAN_HPP_NOEXCEPT
+    {
+      getDispatcher()->vkCmdCopyBufferToImage( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                               static_cast<VkBuffer>( srcBuffer ),
+                                               static_cast<VkImage>( dstImage ),
+                                               static_cast<VkImageLayout>( dstImageLayout ),
+                                               regions.size(),
+                                               reinterpret_cast<const VkBufferImageCopy *>( regions.data() ) );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer(
+      VULKAN_HPP_NAMESPACE::Image                                     srcImage,
+      VULKAN_HPP_NAMESPACE::ImageLayout                               srcImageLayout,
+      VULKAN_HPP_NAMESPACE::Buffer                                    dstBuffer,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions ) const VULKAN_HPP_NOEXCEPT
+    {
+      getDispatcher()->vkCmdCopyImageToBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                               static_cast<VkImage>( srcImage ),
+                                               static_cast<VkImageLayout>( srcImageLayout ),
+                                               static_cast<VkBuffer>( dstBuffer ),
+                                               regions.size(),
+                                               reinterpret_cast<const VkBufferImageCopy *>( regions.data() ) );
+    }
+
+    template <typename T>
+    VULKAN_HPP_INLINE void CommandBuffer::updateBuffer( VULKAN_HPP_NAMESPACE::Buffer     dstBuffer,
+                                                        VULKAN_HPP_NAMESPACE::DeviceSize dstOffset,
+                                                        ArrayProxy<const T> const & data ) const VULKAN_HPP_NOEXCEPT
+    {
+      getDispatcher()->vkCmdUpdateBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                          static_cast<VkBuffer>( dstBuffer ),
+                                          static_cast<VkDeviceSize>( dstOffset ),
+                                          data.size() * sizeof( T ),
+                                          reinterpret_cast<const void *>( data.data() ) );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::fillBuffer( VULKAN_HPP_NAMESPACE::Buffer     dstBuffer,
+                                                      VULKAN_HPP_NAMESPACE::DeviceSize dstOffset,
+                                                      VULKAN_HPP_NAMESPACE::DeviceSize size,
+                                                      uint32_t                         data ) const VULKAN_HPP_NOEXCEPT
+    {
+      getDispatcher()->vkCmdFillBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                        static_cast<VkBuffer>( dstBuffer ),
+                                        static_cast<VkDeviceSize>( dstOffset ),
+                                        static_cast<VkDeviceSize>( size ),
+                                        data );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::clearColorImage(
+      VULKAN_HPP_NAMESPACE::Image                                           image,
+      VULKAN_HPP_NAMESPACE::ImageLayout                                     imageLayout,
+      const ClearColorValue &                                               color,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceRange> const & ranges ) const VULKAN_HPP_NOEXCEPT
+    {
+      getDispatcher()->vkCmdClearColorImage( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                             static_cast<VkImage>( image ),
+                                             static_cast<VkImageLayout>( imageLayout ),
+                                             reinterpret_cast<const VkClearColorValue *>( &color ),
+                                             ranges.size(),
+                                             reinterpret_cast<const VkImageSubresourceRange *>( ranges.data() ) );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::clearDepthStencilImage(
+      VULKAN_HPP_NAMESPACE::Image                                           image,
+      VULKAN_HPP_NAMESPACE::ImageLayout                                     imageLayout,
+      const ClearDepthStencilValue &                                        depthStencil,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceRange> const & ranges ) const VULKAN_HPP_NOEXCEPT
+    {
+      getDispatcher()->vkCmdClearDepthStencilImage(
+        static_cast<VkCommandBuffer>( m_commandBuffer ),
+        static_cast<VkImage>( image ),
+        static_cast<VkImageLayout>( imageLayout ),
+        reinterpret_cast<const VkClearDepthStencilValue *>( &depthStencil ),
+        ranges.size(),
+        reinterpret_cast<const VkImageSubresourceRange *>( ranges.data() ) );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::clearAttachments(
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearAttachment> const & attachments,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearRect> const &       rects ) const VULKAN_HPP_NOEXCEPT
+    {
+      getDispatcher()->vkCmdClearAttachments( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                              attachments.size(),
+                                              reinterpret_cast<const VkClearAttachment *>( attachments.data() ),
+                                              rects.size(),
+                                              reinterpret_cast<const VkClearRect *>( rects.data() ) );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::resolveImage(
+      VULKAN_HPP_NAMESPACE::Image                                  srcImage,
+      VULKAN_HPP_NAMESPACE::ImageLayout                            srcImageLayout,
+      VULKAN_HPP_NAMESPACE::Image                                  dstImage,
+      VULKAN_HPP_NAMESPACE::ImageLayout                            dstImageLayout,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageResolve> const & regions ) const VULKAN_HPP_NOEXCEPT
+    {
+      getDispatcher()->vkCmdResolveImage( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                          static_cast<VkImage>( srcImage ),
+                                          static_cast<VkImageLayout>( srcImageLayout ),
+                                          static_cast<VkImage>( dstImage ),
+                                          static_cast<VkImageLayout>( dstImageLayout ),
+                                          regions.size(),
+                                          reinterpret_cast<const VkImageResolve *>( regions.data() ) );
+    }
+
+    VULKAN_HPP_INLINE void
+      CommandBuffer::setEvent( VULKAN_HPP_NAMESPACE::Event              event,
+                               VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask ) const VULKAN_HPP_NOEXCEPT
+    {
+      getDispatcher()->vkCmdSetEvent( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                      static_cast<VkEvent>( event ),
+                                      static_cast<VkPipelineStageFlags>( stageMask ) );
+    }
+
+    VULKAN_HPP_INLINE void
+      CommandBuffer::resetEvent( VULKAN_HPP_NAMESPACE::Event              event,
+                                 VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask ) const VULKAN_HPP_NOEXCEPT
+    {
+      getDispatcher()->vkCmdResetEvent( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                        static_cast<VkEvent>( event ),
+                                        static_cast<VkPipelineStageFlags>( stageMask ) );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::waitEvents(
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const &               events,
+      VULKAN_HPP_NAMESPACE::PipelineStageFlags                            srcStageMask,
+      VULKAN_HPP_NAMESPACE::PipelineStageFlags                            dstStageMask,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const &       memoryBarriers,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const & bufferMemoryBarriers,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const & imageMemoryBarriers ) const VULKAN_HPP_NOEXCEPT
+    {
+      getDispatcher()->vkCmdWaitEvents( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                        events.size(),
+                                        reinterpret_cast<const VkEvent *>( events.data() ),
+                                        static_cast<VkPipelineStageFlags>( srcStageMask ),
+                                        static_cast<VkPipelineStageFlags>( dstStageMask ),
+                                        memoryBarriers.size(),
+                                        reinterpret_cast<const VkMemoryBarrier *>( memoryBarriers.data() ),
+                                        bufferMemoryBarriers.size(),
+                                        reinterpret_cast<const VkBufferMemoryBarrier *>( bufferMemoryBarriers.data() ),
+                                        imageMemoryBarriers.size(),
+                                        reinterpret_cast<const VkImageMemoryBarrier *>( imageMemoryBarriers.data() ) );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier(
+      VULKAN_HPP_NAMESPACE::PipelineStageFlags                            srcStageMask,
+      VULKAN_HPP_NAMESPACE::PipelineStageFlags                            dstStageMask,
+      VULKAN_HPP_NAMESPACE::DependencyFlags                               dependencyFlags,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const &       memoryBarriers,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const & bufferMemoryBarriers,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const & imageMemoryBarriers ) const VULKAN_HPP_NOEXCEPT
+    {
+      getDispatcher()->vkCmdPipelineBarrier(
+        static_cast<VkCommandBuffer>( m_commandBuffer ),
+        static_cast<VkPipelineStageFlags>( srcStageMask ),
+        static_cast<VkPipelineStageFlags>( dstStageMask ),
+        static_cast<VkDependencyFlags>( dependencyFlags ),
+        memoryBarriers.size(),
+        reinterpret_cast<const VkMemoryBarrier *>( memoryBarriers.data() ),
+        bufferMemoryBarriers.size(),
+        reinterpret_cast<const VkBufferMemoryBarrier *>( bufferMemoryBarriers.data() ),
+        imageMemoryBarriers.size(),
+        reinterpret_cast<const VkImageMemoryBarrier *>( imageMemoryBarriers.data() ) );
+    }
+
+    VULKAN_HPP_INLINE void
+      CommandBuffer::beginQuery( VULKAN_HPP_NAMESPACE::QueryPool         queryPool,
+                                 uint32_t                                query,
+                                 VULKAN_HPP_NAMESPACE::QueryControlFlags flags ) const VULKAN_HPP_NOEXCEPT
+    {
+      getDispatcher()->vkCmdBeginQuery( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                        static_cast<VkQueryPool>( queryPool ),
+                                        query,
+                                        static_cast<VkQueryControlFlags>( flags ) );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::endQuery( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
+                                                    uint32_t                        query ) const VULKAN_HPP_NOEXCEPT
+    {
+      getDispatcher()->vkCmdEndQuery(
+        static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkQueryPool>( queryPool ), query );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::resetQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
+                                                          uint32_t                        firstQuery,
+                                                          uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT
+    {
+      getDispatcher()->vkCmdResetQueryPool( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                            static_cast<VkQueryPool>( queryPool ),
+                                            firstQuery,
+                                            queryCount );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::writeTimestamp( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage,
+                                                          VULKAN_HPP_NAMESPACE::QueryPool             queryPool,
+                                                          uint32_t query ) const VULKAN_HPP_NOEXCEPT
+    {
+      getDispatcher()->vkCmdWriteTimestamp( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                            static_cast<VkPipelineStageFlagBits>( pipelineStage ),
+                                            static_cast<VkQueryPool>( queryPool ),
+                                            query );
+    }
+
+    VULKAN_HPP_INLINE void
+      CommandBuffer::copyQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool        queryPool,
+                                           uint32_t                               firstQuery,
+                                           uint32_t                               queryCount,
+                                           VULKAN_HPP_NAMESPACE::Buffer           dstBuffer,
+                                           VULKAN_HPP_NAMESPACE::DeviceSize       dstOffset,
+                                           VULKAN_HPP_NAMESPACE::DeviceSize       stride,
+                                           VULKAN_HPP_NAMESPACE::QueryResultFlags flags ) const VULKAN_HPP_NOEXCEPT
+    {
+      getDispatcher()->vkCmdCopyQueryPoolResults( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                                  static_cast<VkQueryPool>( queryPool ),
+                                                  firstQuery,
+                                                  queryCount,
+                                                  static_cast<VkBuffer>( dstBuffer ),
+                                                  static_cast<VkDeviceSize>( dstOffset ),
+                                                  static_cast<VkDeviceSize>( stride ),
+                                                  static_cast<VkQueryResultFlags>( flags ) );
+    }
+
+    template <typename T>
+    VULKAN_HPP_INLINE void CommandBuffer::pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout   layout,
+                                                         VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags,
+                                                         uint32_t                               offset,
+                                                         ArrayProxy<const T> const & values ) const VULKAN_HPP_NOEXCEPT
+    {
+      getDispatcher()->vkCmdPushConstants( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                           static_cast<VkPipelineLayout>( layout ),
+                                           static_cast<VkShaderStageFlags>( stageFlags ),
+                                           offset,
+                                           values.size() * sizeof( T ),
+                                           reinterpret_cast<const void *>( values.data() ) );
+    }
+
+    VULKAN_HPP_INLINE void
+      CommandBuffer::beginRenderPass( const RenderPassBeginInfo &           renderPassBegin,
+                                      VULKAN_HPP_NAMESPACE::SubpassContents contents ) const VULKAN_HPP_NOEXCEPT
+    {
+      getDispatcher()->vkCmdBeginRenderPass( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                             reinterpret_cast<const VkRenderPassBeginInfo *>( &renderPassBegin ),
+                                             static_cast<VkSubpassContents>( contents ) );
+    }
+
+    VULKAN_HPP_INLINE void
+      CommandBuffer::nextSubpass( VULKAN_HPP_NAMESPACE::SubpassContents contents ) const VULKAN_HPP_NOEXCEPT
+    {
+      getDispatcher()->vkCmdNextSubpass( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                         static_cast<VkSubpassContents>( contents ) );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::endRenderPass() const VULKAN_HPP_NOEXCEPT
+    {
+      getDispatcher()->vkCmdEndRenderPass( static_cast<VkCommandBuffer>( m_commandBuffer ) );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::executeCommands(
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers ) const VULKAN_HPP_NOEXCEPT
+    {
+      getDispatcher()->vkCmdExecuteCommands( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                             commandBuffers.size(),
+                                             reinterpret_cast<const VkCommandBuffer *>( commandBuffers.data() ) );
+    }
+
+    //=== VK_VERSION_1_1 ===
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint32_t Context::enumerateInstanceVersion() const
+    {
+      uint32_t                     apiVersion;
+      VULKAN_HPP_NAMESPACE::Result result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkEnumerateInstanceVersion( &apiVersion ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Context::enumerateInstanceVersion" );
+      }
+      return apiVersion;
+    }
+
+    VULKAN_HPP_INLINE void
+      Device::bindBufferMemory2( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos ) const
+    {
+      VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
+        getDispatcher()->vkBindBufferMemory2( static_cast<VkDevice>( m_device ),
+                                              bindInfos.size(),
+                                              reinterpret_cast<const VkBindBufferMemoryInfo *>( bindInfos.data() ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindBufferMemory2" );
+      }
+    }
+
+    VULKAN_HPP_INLINE void
+      Device::bindImageMemory2( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos ) const
+    {
+      VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
+        getDispatcher()->vkBindImageMemory2( static_cast<VkDevice>( m_device ),
+                                             bindInfos.size(),
+                                             reinterpret_cast<const VkBindImageMemoryInfo *>( bindInfos.data() ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindImageMemory2" );
+      }
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags
+                                           Device::getGroupPeerMemoryFeatures( uint32_t heapIndex,
+                                          uint32_t localDeviceIndex,
+                                          uint32_t remoteDeviceIndex ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags peerMemoryFeatures;
+      getDispatcher()->vkGetDeviceGroupPeerMemoryFeatures(
+        static_cast<VkDevice>( m_device ),
+        heapIndex,
+        localDeviceIndex,
+        remoteDeviceIndex,
+        reinterpret_cast<VkPeerMemoryFeatureFlags *>( &peerMemoryFeatures ) );
+      return peerMemoryFeatures;
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::setDeviceMask( uint32_t deviceMask ) const VULKAN_HPP_NOEXCEPT
+    {
+      getDispatcher()->vkCmdSetDeviceMask( static_cast<VkCommandBuffer>( m_commandBuffer ), deviceMask );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::dispatchBase( uint32_t baseGroupX,
+                                                        uint32_t baseGroupY,
+                                                        uint32_t baseGroupZ,
+                                                        uint32_t groupCountX,
+                                                        uint32_t groupCountY,
+                                                        uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT
+    {
+      getDispatcher()->vkCmdDispatchBase( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                          baseGroupX,
+                                          baseGroupY,
+                                          baseGroupZ,
+                                          groupCountX,
+                                          groupCountY,
+                                          groupCountZ );
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>
+                                           Instance::enumeratePhysicalDeviceGroups() const
+    {
+      std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties> physicalDeviceGroupProperties;
+      uint32_t                                                         physicalDeviceGroupCount;
       VULKAN_HPP_NAMESPACE::Result                                     result;
       do
       {
-        result =
-          static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(
-            static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, nullptr ) );
-        if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount )
+        result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkEnumeratePhysicalDeviceGroups(
+          static_cast<VkInstance>( m_instance ), &physicalDeviceGroupCount, nullptr ) );
+        if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && physicalDeviceGroupCount )
         {
-          properties.resize( propertyCount );
-          result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-            getDispatcher()->vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(
-              static_cast<VkPhysicalDevice>( m_physicalDevice ),
-              &propertyCount,
-              reinterpret_cast<VkCooperativeMatrixPropertiesNV *>( properties.data() ) ) );
-          VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+          physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
+          result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkEnumeratePhysicalDeviceGroups(
+            static_cast<VkInstance>( m_instance ),
+            &physicalDeviceGroupCount,
+            reinterpret_cast<VkPhysicalDeviceGroupProperties *>( physicalDeviceGroupProperties.data() ) ) );
+          VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() );
         }
       } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
-      if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( propertyCount < properties.size() ) )
+      if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) &&
+           ( physicalDeviceGroupCount < physicalDeviceGroupProperties.size() ) )
       {
-        properties.resize( propertyCount );
+        physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
       }
       if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
       {
-        throwResultException( result,
-                              VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCooperativeMatrixPropertiesNV" );
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDeviceGroups" );
       }
+      return physicalDeviceGroupProperties;
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2
+      Device::getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements;
+      getDispatcher()->vkGetImageMemoryRequirements2(
+        static_cast<VkDevice>( m_device ),
+        reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( &info ),
+        reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
+      return memoryRequirements;
+    }
+
+    template <typename X, typename Y, typename... Z>
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
+      Device::getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT
+    {
+      StructureChain<X, Y, Z...>                  structureChain;
+      VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements =
+        structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>();
+      getDispatcher()->vkGetImageMemoryRequirements2(
+        static_cast<VkDevice>( m_device ),
+        reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( &info ),
+        reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
+      return structureChain;
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2
+      Device::getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements;
+      getDispatcher()->vkGetBufferMemoryRequirements2(
+        static_cast<VkDevice>( m_device ),
+        reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( &info ),
+        reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
+      return memoryRequirements;
+    }
+
+    template <typename X, typename Y, typename... Z>
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
+      Device::getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT
+    {
+      StructureChain<X, Y, Z...>                  structureChain;
+      VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements =
+        structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>();
+      getDispatcher()->vkGetBufferMemoryRequirements2(
+        static_cast<VkDevice>( m_device ),
+        reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( &info ),
+        reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
+      return structureChain;
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>
+      Device::getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info ) const
+      VULKAN_HPP_NOEXCEPT
+    {
+      uint32_t sparseMemoryRequirementCount;
+      getDispatcher()->vkGetImageSparseMemoryRequirements2(
+        static_cast<VkDevice>( m_device ),
+        reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ),
+        &sparseMemoryRequirementCount,
+        nullptr );
+      std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2> sparseMemoryRequirements(
+        sparseMemoryRequirementCount );
+      getDispatcher()->vkGetImageSparseMemoryRequirements2(
+        static_cast<VkDevice>( m_device ),
+        reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ),
+        &sparseMemoryRequirementCount,
+        reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) );
+      VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() );
+      return sparseMemoryRequirements;
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2
+                                           PhysicalDevice::getFeatures2() const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 features;
+      getDispatcher()->vkGetPhysicalDeviceFeatures2( static_cast<VkPhysicalDevice>( m_physicalDevice ),
+                                                     reinterpret_cast<VkPhysicalDeviceFeatures2 *>( &features ) );
+      return features;
+    }
+
+    template <typename X, typename Y, typename... Z>
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
+                                           PhysicalDevice::getFeatures2() const VULKAN_HPP_NOEXCEPT
+    {
+      StructureChain<X, Y, Z...>                      structureChain;
+      VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 & features =
+        structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2>();
+      getDispatcher()->vkGetPhysicalDeviceFeatures2( static_cast<VkPhysicalDevice>( m_physicalDevice ),
+                                                     reinterpret_cast<VkPhysicalDeviceFeatures2 *>( &features ) );
+      return structureChain;
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2
+                                           PhysicalDevice::getProperties2() const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 properties;
+      getDispatcher()->vkGetPhysicalDeviceProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ),
+                                                       reinterpret_cast<VkPhysicalDeviceProperties2 *>( &properties ) );
       return properties;
     }
 
-#  if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Bool32
-                                           PhysicalDevice::getDirectFBPresentationSupportEXT( uint32_t    queueFamilyIndex,
-                                                         IDirectFB & dfb ) const VULKAN_HPP_NOEXCEPT
+    template <typename X, typename Y, typename... Z>
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
+                                           PhysicalDevice::getProperties2() const VULKAN_HPP_NOEXCEPT
     {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetPhysicalDeviceDirectFBPresentationSupportEXT &&
-        "Function <vkGetPhysicalDeviceDirectFBPresentationSupportEXT> needs extension <VK_EXT_directfb_surface> enabled!" );
-
-      return static_cast<VULKAN_HPP_NAMESPACE::Bool32>(
-        getDispatcher()->vkGetPhysicalDeviceDirectFBPresentationSupportEXT(
-          static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex, &dfb ) );
+      StructureChain<X, Y, Z...>                        structureChain;
+      VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 & properties =
+        structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2>();
+      getDispatcher()->vkGetPhysicalDeviceProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ),
+                                                       reinterpret_cast<VkPhysicalDeviceProperties2 *>( &properties ) );
+      return structureChain;
     }
-#  endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
 
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR>
-                                           PhysicalDevice::getDisplayPlaneProperties2KHR() const
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::FormatProperties2
+      PhysicalDevice::getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format ) const VULKAN_HPP_NOEXCEPT
     {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetPhysicalDeviceDisplayPlaneProperties2KHR &&
-        "Function <vkGetPhysicalDeviceDisplayPlaneProperties2KHR> needs extension <VK_KHR_get_display_properties2> enabled!" );
+      VULKAN_HPP_NAMESPACE::FormatProperties2 formatProperties;
+      getDispatcher()->vkGetPhysicalDeviceFormatProperties2(
+        static_cast<VkPhysicalDevice>( m_physicalDevice ),
+        static_cast<VkFormat>( format ),
+        reinterpret_cast<VkFormatProperties2 *>( &formatProperties ) );
+      return formatProperties;
+    }
 
-      std::vector<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR> properties;
-      uint32_t                                                      propertyCount;
-      VULKAN_HPP_NAMESPACE::Result                                  result;
-      do
-      {
-        result =
-          static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceDisplayPlaneProperties2KHR(
-            static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, nullptr ) );
-        if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount )
-        {
-          properties.resize( propertyCount );
-          result =
-            static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceDisplayPlaneProperties2KHR(
-              static_cast<VkPhysicalDevice>( m_physicalDevice ),
-              &propertyCount,
-              reinterpret_cast<VkDisplayPlaneProperties2KHR *>( properties.data() ) ) );
-          VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
-        }
-      } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
-      if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( propertyCount < properties.size() ) )
-      {
-        properties.resize( propertyCount );
-      }
+    template <typename X, typename Y, typename... Z>
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
+      PhysicalDevice::getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format ) const VULKAN_HPP_NOEXCEPT
+    {
+      StructureChain<X, Y, Z...>                structureChain;
+      VULKAN_HPP_NAMESPACE::FormatProperties2 & formatProperties =
+        structureChain.template get<VULKAN_HPP_NAMESPACE::FormatProperties2>();
+      getDispatcher()->vkGetPhysicalDeviceFormatProperties2(
+        static_cast<VkPhysicalDevice>( m_physicalDevice ),
+        static_cast<VkFormat>( format ),
+        reinterpret_cast<VkFormatProperties2 *>( &formatProperties ) );
+      return structureChain;
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ImageFormatProperties2
+      PhysicalDevice::getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const
+    {
+      VULKAN_HPP_NAMESPACE::ImageFormatProperties2 imageFormatProperties;
+      VULKAN_HPP_NAMESPACE::Result                 result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2(
+          static_cast<VkPhysicalDevice>( m_physicalDevice ),
+          reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( &imageFormatInfo ),
+          reinterpret_cast<VkImageFormatProperties2 *>( &imageFormatProperties ) ) );
       if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
       {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneProperties2KHR" );
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2" );
       }
+      return imageFormatProperties;
+    }
+
+    template <typename X, typename Y, typename... Z>
+    VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
+      PhysicalDevice::getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const
+    {
+      StructureChain<X, Y, Z...>                     structureChain;
+      VULKAN_HPP_NAMESPACE::ImageFormatProperties2 & imageFormatProperties =
+        structureChain.template get<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>();
+      VULKAN_HPP_NAMESPACE::Result result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2(
+          static_cast<VkPhysicalDevice>( m_physicalDevice ),
+          reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( &imageFormatInfo ),
+          reinterpret_cast<VkImageFormatProperties2 *>( &imageFormatProperties ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2" );
+      }
+      return structureChain;
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>
+                                           PhysicalDevice::getQueueFamilyProperties2() const VULKAN_HPP_NOEXCEPT
+    {
+      uint32_t queueFamilyPropertyCount;
+      getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2(
+        static_cast<VkPhysicalDevice>( m_physicalDevice ), &queueFamilyPropertyCount, nullptr );
+      std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> queueFamilyProperties( queueFamilyPropertyCount );
+      getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2(
+        static_cast<VkPhysicalDevice>( m_physicalDevice ),
+        &queueFamilyPropertyCount,
+        reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) );
+      VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() );
+      return queueFamilyProperties;
+    }
+
+    template <typename StructureChain>
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<StructureChain> PhysicalDevice::getQueueFamilyProperties2() const
+    {
+      uint32_t queueFamilyPropertyCount;
+      getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2(
+        static_cast<VkPhysicalDevice>( m_physicalDevice ), &queueFamilyPropertyCount, nullptr );
+      std::vector<StructureChain>                               returnVector( queueFamilyPropertyCount );
+      std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> queueFamilyProperties( queueFamilyPropertyCount );
+      for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ )
+      {
+        queueFamilyProperties[i].pNext =
+          returnVector[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>().pNext;
+      }
+      getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2(
+        static_cast<VkPhysicalDevice>( m_physicalDevice ),
+        &queueFamilyPropertyCount,
+        reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) );
+      VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() );
+      for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ )
+      {
+        returnVector[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>() = queueFamilyProperties[i];
+      }
+      return returnVector;
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2
+                                           PhysicalDevice::getMemoryProperties2() const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 memoryProperties;
+      getDispatcher()->vkGetPhysicalDeviceMemoryProperties2(
+        static_cast<VkPhysicalDevice>( m_physicalDevice ),
+        reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( &memoryProperties ) );
+      return memoryProperties;
+    }
+
+    template <typename X, typename Y, typename... Z>
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
+                                           PhysicalDevice::getMemoryProperties2() const VULKAN_HPP_NOEXCEPT
+    {
+      StructureChain<X, Y, Z...>                              structureChain;
+      VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 & memoryProperties =
+        structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2>();
+      getDispatcher()->vkGetPhysicalDeviceMemoryProperties2(
+        static_cast<VkPhysicalDevice>( m_physicalDevice ),
+        reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( &memoryProperties ) );
+      return structureChain;
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>
+      PhysicalDevice::getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo ) const
+      VULKAN_HPP_NOEXCEPT
+    {
+      uint32_t propertyCount;
+      getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties2(
+        static_cast<VkPhysicalDevice>( m_physicalDevice ),
+        reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ),
+        &propertyCount,
+        nullptr );
+      std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2> properties( propertyCount );
+      getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties2(
+        static_cast<VkPhysicalDevice>( m_physicalDevice ),
+        reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ),
+        &propertyCount,
+        reinterpret_cast<VkSparseImageFormatProperties2 *>( properties.data() ) );
+      VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
       return properties;
     }
 
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR>
-                                           PhysicalDevice::getDisplayPlanePropertiesKHR() const
+    VULKAN_HPP_INLINE void
+      CommandPool::trim( VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags ) const VULKAN_HPP_NOEXCEPT
     {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetPhysicalDeviceDisplayPlanePropertiesKHR &&
-        "Function <vkGetPhysicalDeviceDisplayPlanePropertiesKHR> needs extension <VK_KHR_display> enabled!" );
-
-      std::vector<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR> properties;
-      uint32_t                                                     propertyCount;
-      VULKAN_HPP_NAMESPACE::Result                                 result;
-      do
-      {
-        result =
-          static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
-            static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, nullptr ) );
-        if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount )
-        {
-          properties.resize( propertyCount );
-          result =
-            static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
-              static_cast<VkPhysicalDevice>( m_physicalDevice ),
-              &propertyCount,
-              reinterpret_cast<VkDisplayPlanePropertiesKHR *>( properties.data() ) ) );
-          VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
-        }
-      } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
-      if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( propertyCount < properties.size() ) )
-      {
-        properties.resize( propertyCount );
-      }
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlanePropertiesKHR" );
-      }
-      return properties;
+      getDispatcher()->vkTrimCommandPool( static_cast<VkDevice>( m_device ),
+                                          static_cast<VkCommandPool>( m_commandPool ),
+                                          static_cast<VkCommandPoolTrimFlags>( flags ) );
     }
 
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR>
-                                           PhysicalDevice::getDisplayProperties2KHR() const
+    VULKAN_HPP_INLINE void
+      DescriptorSet::updateWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
+                                         const void * pData ) const VULKAN_HPP_NOEXCEPT
     {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetPhysicalDeviceDisplayProperties2KHR &&
-        "Function <vkGetPhysicalDeviceDisplayProperties2KHR> needs extension <VK_KHR_get_display_properties2> enabled!" );
-
-      std::vector<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR> properties;
-      uint32_t                                                 propertyCount;
-      VULKAN_HPP_NAMESPACE::Result                             result;
-      do
-      {
-        result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceDisplayProperties2KHR(
-          static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, nullptr ) );
-        if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount )
-        {
-          properties.resize( propertyCount );
-          result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceDisplayProperties2KHR(
-            static_cast<VkPhysicalDevice>( m_physicalDevice ),
-            &propertyCount,
-            reinterpret_cast<VkDisplayProperties2KHR *>( properties.data() ) ) );
-          VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
-        }
-      } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
-      if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( propertyCount < properties.size() ) )
-      {
-        properties.resize( propertyCount );
-      }
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayProperties2KHR" );
-      }
-      return properties;
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR>
-                                           PhysicalDevice::getDisplayPropertiesKHR() const
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetPhysicalDeviceDisplayPropertiesKHR &&
-        "Function <vkGetPhysicalDeviceDisplayPropertiesKHR> needs extension <VK_KHR_display> enabled!" );
-
-      std::vector<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR> properties;
-      uint32_t                                                propertyCount;
-      VULKAN_HPP_NAMESPACE::Result                            result;
-      do
-      {
-        result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceDisplayPropertiesKHR(
-          static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, nullptr ) );
-        if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount )
-        {
-          properties.resize( propertyCount );
-          result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceDisplayPropertiesKHR(
-            static_cast<VkPhysicalDevice>( m_physicalDevice ),
-            &propertyCount,
-            reinterpret_cast<VkDisplayPropertiesKHR *>( properties.data() ) ) );
-          VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
-        }
-      } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
-      if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( propertyCount < properties.size() ) )
-      {
-        properties.resize( propertyCount );
-      }
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPropertiesKHR" );
-      }
-      return properties;
+      getDispatcher()->vkUpdateDescriptorSetWithTemplate(
+        static_cast<VkDevice>( m_device ),
+        static_cast<VkDescriptorSet>( m_descriptorSet ),
+        static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
+        pData );
     }
 
     VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalBufferProperties
@@ -8415,22 +9704,6 @@ namespace VULKAN_HPP_NAMESPACE
       return externalBufferProperties;
     }
 
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalBufferProperties
-                                           PhysicalDevice::getExternalBufferPropertiesKHR(
-        const PhysicalDeviceExternalBufferInfo & externalBufferInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetPhysicalDeviceExternalBufferPropertiesKHR &&
-        "Function <vkGetPhysicalDeviceExternalBufferPropertiesKHR> needs extension <VK_KHR_external_memory_capabilities> enabled!" );
-
-      VULKAN_HPP_NAMESPACE::ExternalBufferProperties externalBufferProperties;
-      getDispatcher()->vkGetPhysicalDeviceExternalBufferPropertiesKHR(
-        static_cast<VkPhysicalDevice>( m_physicalDevice ),
-        reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo *>( &externalBufferInfo ),
-        reinterpret_cast<VkExternalBufferProperties *>( &externalBufferProperties ) );
-      return externalBufferProperties;
-    }
-
     VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalFenceProperties
       PhysicalDevice::getExternalFenceProperties( const PhysicalDeviceExternalFenceInfo & externalFenceInfo ) const
       VULKAN_HPP_NOEXCEPT
@@ -8443,54 +9716,6 @@ namespace VULKAN_HPP_NAMESPACE
       return externalFenceProperties;
     }
 
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalFenceProperties
-      PhysicalDevice::getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfo & externalFenceInfo ) const
-      VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetPhysicalDeviceExternalFencePropertiesKHR &&
-        "Function <vkGetPhysicalDeviceExternalFencePropertiesKHR> needs extension <VK_KHR_external_fence_capabilities> enabled!" );
-
-      VULKAN_HPP_NAMESPACE::ExternalFenceProperties externalFenceProperties;
-      getDispatcher()->vkGetPhysicalDeviceExternalFencePropertiesKHR(
-        static_cast<VkPhysicalDevice>( m_physicalDevice ),
-        reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo *>( &externalFenceInfo ),
-        reinterpret_cast<VkExternalFenceProperties *>( &externalFenceProperties ) );
-      return externalFenceProperties;
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV
-                                           PhysicalDevice::getExternalImageFormatPropertiesNV(
-        VULKAN_HPP_NAMESPACE::Format                          format,
-        VULKAN_HPP_NAMESPACE::ImageType                       type,
-        VULKAN_HPP_NAMESPACE::ImageTiling                     tiling,
-        VULKAN_HPP_NAMESPACE::ImageUsageFlags                 usage,
-        VULKAN_HPP_NAMESPACE::ImageCreateFlags                flags,
-        VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV externalHandleType ) const
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetPhysicalDeviceExternalImageFormatPropertiesNV &&
-        "Function <vkGetPhysicalDeviceExternalImageFormatPropertiesNV> needs extension <VK_NV_external_memory_capabilities> enabled!" );
-
-      VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV externalImageFormatProperties;
-      VULKAN_HPP_NAMESPACE::Result                          result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
-          static_cast<VkPhysicalDevice>( m_physicalDevice ),
-          static_cast<VkFormat>( format ),
-          static_cast<VkImageType>( type ),
-          static_cast<VkImageTiling>( tiling ),
-          static_cast<VkImageUsageFlags>( usage ),
-          static_cast<VkImageCreateFlags>( flags ),
-          static_cast<VkExternalMemoryHandleTypeFlagsNV>( externalHandleType ),
-          reinterpret_cast<VkExternalImageFormatPropertiesNV *>( &externalImageFormatProperties ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result,
-                              VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getExternalImageFormatPropertiesNV" );
-      }
-      return externalImageFormatProperties;
-    }
-
     VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties
                                            PhysicalDevice::getExternalSemaphoreProperties(
         const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo ) const VULKAN_HPP_NOEXCEPT
@@ -8503,363 +9728,394 @@ namespace VULKAN_HPP_NAMESPACE
       return externalSemaphoreProperties;
     }
 
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties
-                                           PhysicalDevice::getExternalSemaphorePropertiesKHR(
-        const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetPhysicalDeviceExternalSemaphorePropertiesKHR &&
-        "Function <vkGetPhysicalDeviceExternalSemaphorePropertiesKHR> needs extension <VK_KHR_external_semaphore_capabilities> enabled!" );
-
-      VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties externalSemaphoreProperties;
-      getDispatcher()->vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
-        static_cast<VkPhysicalDevice>( m_physicalDevice ),
-        reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo *>( &externalSemaphoreInfo ),
-        reinterpret_cast<VkExternalSemaphoreProperties *>( &externalSemaphoreProperties ) );
-      return externalSemaphoreProperties;
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures
-                                           PhysicalDevice::getFeatures() const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures features;
-      getDispatcher()->vkGetPhysicalDeviceFeatures( static_cast<VkPhysicalDevice>( m_physicalDevice ),
-                                                    reinterpret_cast<VkPhysicalDeviceFeatures *>( &features ) );
-      return features;
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2
-                                           PhysicalDevice::getFeatures2() const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 features;
-      getDispatcher()->vkGetPhysicalDeviceFeatures2( static_cast<VkPhysicalDevice>( m_physicalDevice ),
-                                                     reinterpret_cast<VkPhysicalDeviceFeatures2 *>( &features ) );
-      return features;
-    }
-
-    template <typename X, typename Y, typename... Z>
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
-                                           PhysicalDevice::getFeatures2() const VULKAN_HPP_NOEXCEPT
-    {
-      StructureChain<X, Y, Z...>                      structureChain;
-      VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 & features =
-        structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2>();
-      getDispatcher()->vkGetPhysicalDeviceFeatures2( static_cast<VkPhysicalDevice>( m_physicalDevice ),
-                                                     reinterpret_cast<VkPhysicalDeviceFeatures2 *>( &features ) );
-      return structureChain;
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2
-                                           PhysicalDevice::getFeatures2KHR() const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetPhysicalDeviceFeatures2KHR &&
-        "Function <vkGetPhysicalDeviceFeatures2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!" );
-
-      VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 features;
-      getDispatcher()->vkGetPhysicalDeviceFeatures2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
-                                                        reinterpret_cast<VkPhysicalDeviceFeatures2 *>( &features ) );
-      return features;
-    }
-
-    template <typename X, typename Y, typename... Z>
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
-                                           PhysicalDevice::getFeatures2KHR() const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetPhysicalDeviceFeatures2KHR &&
-        "Function <vkGetPhysicalDeviceFeatures2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!" );
-
-      StructureChain<X, Y, Z...>                      structureChain;
-      VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 & features =
-        structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2>();
-      getDispatcher()->vkGetPhysicalDeviceFeatures2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
-                                                        reinterpret_cast<VkPhysicalDeviceFeatures2 *>( &features ) );
-      return structureChain;
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::FormatProperties
-      PhysicalDevice::getFormatProperties( VULKAN_HPP_NAMESPACE::Format format ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_NAMESPACE::FormatProperties formatProperties;
-      getDispatcher()->vkGetPhysicalDeviceFormatProperties(
-        static_cast<VkPhysicalDevice>( m_physicalDevice ),
-        static_cast<VkFormat>( format ),
-        reinterpret_cast<VkFormatProperties *>( &formatProperties ) );
-      return formatProperties;
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::FormatProperties2
-      PhysicalDevice::getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_NAMESPACE::FormatProperties2 formatProperties;
-      getDispatcher()->vkGetPhysicalDeviceFormatProperties2(
-        static_cast<VkPhysicalDevice>( m_physicalDevice ),
-        static_cast<VkFormat>( format ),
-        reinterpret_cast<VkFormatProperties2 *>( &formatProperties ) );
-      return formatProperties;
-    }
-
-    template <typename X, typename Y, typename... Z>
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
-      PhysicalDevice::getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format ) const VULKAN_HPP_NOEXCEPT
-    {
-      StructureChain<X, Y, Z...>                structureChain;
-      VULKAN_HPP_NAMESPACE::FormatProperties2 & formatProperties =
-        structureChain.template get<VULKAN_HPP_NAMESPACE::FormatProperties2>();
-      getDispatcher()->vkGetPhysicalDeviceFormatProperties2(
-        static_cast<VkPhysicalDevice>( m_physicalDevice ),
-        static_cast<VkFormat>( format ),
-        reinterpret_cast<VkFormatProperties2 *>( &formatProperties ) );
-      return structureChain;
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::FormatProperties2
-      PhysicalDevice::getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetPhysicalDeviceFormatProperties2KHR &&
-        "Function <vkGetPhysicalDeviceFormatProperties2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!" );
-
-      VULKAN_HPP_NAMESPACE::FormatProperties2 formatProperties;
-      getDispatcher()->vkGetPhysicalDeviceFormatProperties2KHR(
-        static_cast<VkPhysicalDevice>( m_physicalDevice ),
-        static_cast<VkFormat>( format ),
-        reinterpret_cast<VkFormatProperties2 *>( &formatProperties ) );
-      return formatProperties;
-    }
-
-    template <typename X, typename Y, typename... Z>
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
-      PhysicalDevice::getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetPhysicalDeviceFormatProperties2KHR &&
-        "Function <vkGetPhysicalDeviceFormatProperties2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!" );
-
-      StructureChain<X, Y, Z...>                structureChain;
-      VULKAN_HPP_NAMESPACE::FormatProperties2 & formatProperties =
-        structureChain.template get<VULKAN_HPP_NAMESPACE::FormatProperties2>();
-      getDispatcher()->vkGetPhysicalDeviceFormatProperties2KHR(
-        static_cast<VkPhysicalDevice>( m_physicalDevice ),
-        static_cast<VkFormat>( format ),
-        reinterpret_cast<VkFormatProperties2 *>( &formatProperties ) );
-      return structureChain;
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR>
-                                           PhysicalDevice::getFragmentShadingRatesKHR() const
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetPhysicalDeviceFragmentShadingRatesKHR &&
-        "Function <vkGetPhysicalDeviceFragmentShadingRatesKHR> needs extension <VK_KHR_fragment_shading_rate> enabled!" );
-
-      std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR> fragmentShadingRates;
-      uint32_t                                                                fragmentShadingRateCount;
-      VULKAN_HPP_NAMESPACE::Result                                            result;
-      do
-      {
-        result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceFragmentShadingRatesKHR(
-          static_cast<VkPhysicalDevice>( m_physicalDevice ), &fragmentShadingRateCount, nullptr ) );
-        if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && fragmentShadingRateCount )
-        {
-          fragmentShadingRates.resize( fragmentShadingRateCount );
-          result =
-            static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceFragmentShadingRatesKHR(
-              static_cast<VkPhysicalDevice>( m_physicalDevice ),
-              &fragmentShadingRateCount,
-              reinterpret_cast<VkPhysicalDeviceFragmentShadingRateKHR *>( fragmentShadingRates.data() ) ) );
-          VULKAN_HPP_ASSERT( fragmentShadingRateCount <= fragmentShadingRates.size() );
-        }
-      } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
-      if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) &&
-           ( fragmentShadingRateCount < fragmentShadingRates.size() ) )
-      {
-        fragmentShadingRates.resize( fragmentShadingRateCount );
-      }
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getFragmentShadingRatesKHR" );
-      }
-      return fragmentShadingRates;
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ImageFormatProperties
-      PhysicalDevice::getImageFormatProperties( VULKAN_HPP_NAMESPACE::Format           format,
-                                                VULKAN_HPP_NAMESPACE::ImageType        type,
-                                                VULKAN_HPP_NAMESPACE::ImageTiling      tiling,
-                                                VULKAN_HPP_NAMESPACE::ImageUsageFlags  usage,
-                                                VULKAN_HPP_NAMESPACE::ImageCreateFlags flags ) const
-    {
-      VULKAN_HPP_NAMESPACE::ImageFormatProperties imageFormatProperties;
-      VULKAN_HPP_NAMESPACE::Result                result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceImageFormatProperties(
-          static_cast<VkPhysicalDevice>( m_physicalDevice ),
-          static_cast<VkFormat>( format ),
-          static_cast<VkImageType>( type ),
-          static_cast<VkImageTiling>( tiling ),
-          static_cast<VkImageUsageFlags>( usage ),
-          static_cast<VkImageCreateFlags>( flags ),
-          reinterpret_cast<VkImageFormatProperties *>( &imageFormatProperties ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties" );
-      }
-      return imageFormatProperties;
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ImageFormatProperties2
-      PhysicalDevice::getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const
-    {
-      VULKAN_HPP_NAMESPACE::ImageFormatProperties2 imageFormatProperties;
-      VULKAN_HPP_NAMESPACE::Result                 result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2(
-          static_cast<VkPhysicalDevice>( m_physicalDevice ),
-          reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( &imageFormatInfo ),
-          reinterpret_cast<VkImageFormatProperties2 *>( &imageFormatProperties ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2" );
-      }
-      return imageFormatProperties;
-    }
-
-    template <typename X, typename Y, typename... Z>
-    VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
-      PhysicalDevice::getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const
-    {
-      StructureChain<X, Y, Z...>                     structureChain;
-      VULKAN_HPP_NAMESPACE::ImageFormatProperties2 & imageFormatProperties =
-        structureChain.template get<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>();
-      VULKAN_HPP_NAMESPACE::Result result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2(
-          static_cast<VkPhysicalDevice>( m_physicalDevice ),
-          reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( &imageFormatInfo ),
-          reinterpret_cast<VkImageFormatProperties2 *>( &imageFormatProperties ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2" );
-      }
-      return structureChain;
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ImageFormatProperties2
-      PhysicalDevice::getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2KHR &&
-        "Function <vkGetPhysicalDeviceImageFormatProperties2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!" );
-
-      VULKAN_HPP_NAMESPACE::ImageFormatProperties2 imageFormatProperties;
-      VULKAN_HPP_NAMESPACE::Result                 result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2KHR(
-          static_cast<VkPhysicalDevice>( m_physicalDevice ),
-          reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( &imageFormatInfo ),
-          reinterpret_cast<VkImageFormatProperties2 *>( &imageFormatProperties ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2KHR" );
-      }
-      return imageFormatProperties;
-    }
-
-    template <typename X, typename Y, typename... Z>
-    VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
-      PhysicalDevice::getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const
-    {
-      StructureChain<X, Y, Z...>                     structureChain;
-      VULKAN_HPP_NAMESPACE::ImageFormatProperties2 & imageFormatProperties =
-        structureChain.template get<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>();
-      VULKAN_HPP_NAMESPACE::Result result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2KHR(
-          static_cast<VkPhysicalDevice>( m_physicalDevice ),
-          reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( &imageFormatInfo ),
-          reinterpret_cast<VkImageFormatProperties2 *>( &imageFormatProperties ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2KHR" );
-      }
-      return structureChain;
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties
-                                           PhysicalDevice::getMemoryProperties() const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties memoryProperties;
-      getDispatcher()->vkGetPhysicalDeviceMemoryProperties(
-        static_cast<VkPhysicalDevice>( m_physicalDevice ),
-        reinterpret_cast<VkPhysicalDeviceMemoryProperties *>( &memoryProperties ) );
-      return memoryProperties;
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2
-                                           PhysicalDevice::getMemoryProperties2() const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 memoryProperties;
-      getDispatcher()->vkGetPhysicalDeviceMemoryProperties2(
-        static_cast<VkPhysicalDevice>( m_physicalDevice ),
-        reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( &memoryProperties ) );
-      return memoryProperties;
-    }
-
-    template <typename X, typename Y, typename... Z>
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
-                                           PhysicalDevice::getMemoryProperties2() const VULKAN_HPP_NOEXCEPT
-    {
-      StructureChain<X, Y, Z...>                              structureChain;
-      VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 & memoryProperties =
-        structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2>();
-      getDispatcher()->vkGetPhysicalDeviceMemoryProperties2(
-        static_cast<VkPhysicalDevice>( m_physicalDevice ),
-        reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( &memoryProperties ) );
-      return structureChain;
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2
-                                           PhysicalDevice::getMemoryProperties2KHR() const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetPhysicalDeviceMemoryProperties2KHR &&
-        "Function <vkGetPhysicalDeviceMemoryProperties2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!" );
-
-      VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 memoryProperties;
-      getDispatcher()->vkGetPhysicalDeviceMemoryProperties2KHR(
-        static_cast<VkPhysicalDevice>( m_physicalDevice ),
-        reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( &memoryProperties ) );
-      return memoryProperties;
-    }
-
-    template <typename X, typename Y, typename... Z>
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
-                                           PhysicalDevice::getMemoryProperties2KHR() const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetPhysicalDeviceMemoryProperties2KHR &&
-        "Function <vkGetPhysicalDeviceMemoryProperties2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!" );
-
-      StructureChain<X, Y, Z...>                              structureChain;
-      VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 & memoryProperties =
-        structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2>();
-      getDispatcher()->vkGetPhysicalDeviceMemoryProperties2KHR(
-        static_cast<VkPhysicalDevice>( m_physicalDevice ),
-        reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( &memoryProperties ) );
-      return structureChain;
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT
-      PhysicalDevice::getMultisamplePropertiesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples ) const
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport
+      Device::getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo ) const
       VULKAN_HPP_NOEXCEPT
     {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetPhysicalDeviceMultisamplePropertiesEXT &&
-        "Function <vkGetPhysicalDeviceMultisamplePropertiesEXT> needs extension <VK_EXT_sample_locations> enabled!" );
+      VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport support;
+      getDispatcher()->vkGetDescriptorSetLayoutSupport(
+        static_cast<VkDevice>( m_device ),
+        reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ),
+        reinterpret_cast<VkDescriptorSetLayoutSupport *>( &support ) );
+      return support;
+    }
 
-      VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT multisampleProperties;
-      getDispatcher()->vkGetPhysicalDeviceMultisamplePropertiesEXT(
-        static_cast<VkPhysicalDevice>( m_physicalDevice ),
-        static_cast<VkSampleCountFlagBits>( samples ),
-        reinterpret_cast<VkMultisamplePropertiesEXT *>( &multisampleProperties ) );
-      return multisampleProperties;
+    template <typename X, typename Y, typename... Z>
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getDescriptorSetLayoutSupport(
+      const DescriptorSetLayoutCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      StructureChain<X, Y, Z...>                         structureChain;
+      VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport & support =
+        structureChain.template get<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport>();
+      getDispatcher()->vkGetDescriptorSetLayoutSupport(
+        static_cast<VkDevice>( m_device ),
+        reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ),
+        reinterpret_cast<VkDescriptorSetLayoutSupport *>( &support ) );
+      return structureChain;
+    }
+
+    //=== VK_VERSION_1_2 ===
+
+    VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCount( VULKAN_HPP_NAMESPACE::Buffer     buffer,
+                                                             VULKAN_HPP_NAMESPACE::DeviceSize offset,
+                                                             VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
+                                                             VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
+                                                             uint32_t                         maxDrawCount,
+                                                             uint32_t stride ) const VULKAN_HPP_NOEXCEPT
+    {
+      getDispatcher()->vkCmdDrawIndirectCount( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                               static_cast<VkBuffer>( buffer ),
+                                               static_cast<VkDeviceSize>( offset ),
+                                               static_cast<VkBuffer>( countBuffer ),
+                                               static_cast<VkDeviceSize>( countBufferOffset ),
+                                               maxDrawCount,
+                                               stride );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCount( VULKAN_HPP_NAMESPACE::Buffer     buffer,
+                                                                    VULKAN_HPP_NAMESPACE::DeviceSize offset,
+                                                                    VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
+                                                                    VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
+                                                                    uint32_t                         maxDrawCount,
+                                                                    uint32_t stride ) const VULKAN_HPP_NOEXCEPT
+    {
+      getDispatcher()->vkCmdDrawIndexedIndirectCount( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                                      static_cast<VkBuffer>( buffer ),
+                                                      static_cast<VkDeviceSize>( offset ),
+                                                      static_cast<VkBuffer>( countBuffer ),
+                                                      static_cast<VkDeviceSize>( countBufferOffset ),
+                                                      maxDrawCount,
+                                                      stride );
+    }
+
+    VULKAN_HPP_INLINE void
+      CommandBuffer::beginRenderPass2( const RenderPassBeginInfo & renderPassBegin,
+                                       const SubpassBeginInfo &    subpassBeginInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      getDispatcher()->vkCmdBeginRenderPass2( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                              reinterpret_cast<const VkRenderPassBeginInfo *>( &renderPassBegin ),
+                                              reinterpret_cast<const VkSubpassBeginInfo *>( &subpassBeginInfo ) );
+    }
+
+    VULKAN_HPP_INLINE void
+      CommandBuffer::nextSubpass2( const SubpassBeginInfo & subpassBeginInfo,
+                                   const SubpassEndInfo &   subpassEndInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      getDispatcher()->vkCmdNextSubpass2( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                          reinterpret_cast<const VkSubpassBeginInfo *>( &subpassBeginInfo ),
+                                          reinterpret_cast<const VkSubpassEndInfo *>( &subpassEndInfo ) );
+    }
+
+    VULKAN_HPP_INLINE void
+      CommandBuffer::endRenderPass2( const SubpassEndInfo & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      getDispatcher()->vkCmdEndRenderPass2( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                            reinterpret_cast<const VkSubpassEndInfo *>( &subpassEndInfo ) );
+    }
+
+    VULKAN_HPP_INLINE void QueryPool::reset( uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT
+    {
+      getDispatcher()->vkResetQueryPool(
+        static_cast<VkDevice>( m_device ), static_cast<VkQueryPool>( m_queryPool ), firstQuery, queryCount );
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t Semaphore::getCounterValue() const
+    {
+      uint64_t                     value;
+      VULKAN_HPP_NAMESPACE::Result result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetSemaphoreCounterValue(
+          static_cast<VkDevice>( m_device ), static_cast<VkSemaphore>( m_semaphore ), &value ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Semaphore::getCounterValue" );
+      }
+      return value;
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result
+      Device::waitSemaphores( const SemaphoreWaitInfo & waitInfo, uint64_t timeout ) const
+    {
+      VULKAN_HPP_NAMESPACE::Result result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkWaitSemaphores(
+          static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSemaphoreWaitInfo *>( &waitInfo ), timeout ) );
+      if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) &&
+           ( result != VULKAN_HPP_NAMESPACE::Result::eTimeout ) )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::waitSemaphores" );
+      }
+      return result;
+    }
+
+    VULKAN_HPP_INLINE void Device::signalSemaphore( const SemaphoreSignalInfo & signalInfo ) const
+    {
+      VULKAN_HPP_NAMESPACE::Result result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkSignalSemaphore(
+          static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSemaphoreSignalInfo *>( &signalInfo ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::signalSemaphore" );
+      }
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceAddress
+      Device::getBufferAddress( const BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT
+    {
+      return static_cast<VULKAN_HPP_NAMESPACE::DeviceAddress>( getDispatcher()->vkGetBufferDeviceAddress(
+        static_cast<VkDevice>( m_device ), reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) ) );
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t
+      Device::getBufferOpaqueCaptureAddress( const BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT
+    {
+      return getDispatcher()->vkGetBufferOpaqueCaptureAddress(
+        static_cast<VkDevice>( m_device ), reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) );
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t Device::getMemoryOpaqueCaptureAddress(
+      const DeviceMemoryOpaqueCaptureAddressInfo & info ) const VULKAN_HPP_NOEXCEPT
+    {
+      return getDispatcher()->vkGetDeviceMemoryOpaqueCaptureAddress(
+        static_cast<VkDevice>( m_device ), reinterpret_cast<const VkDeviceMemoryOpaqueCaptureAddressInfo *>( &info ) );
+    }
+
+    //=== VK_KHR_surface ===
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Bool32
+      PhysicalDevice::getSurfaceSupportKHR( uint32_t queueFamilyIndex, VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceSurfaceSupportKHR &&
+                         "Function <vkGetPhysicalDeviceSurfaceSupportKHR> needs extension <VK_KHR_surface> enabled!" );
+
+      VULKAN_HPP_NAMESPACE::Bool32 supported;
+      VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
+        getDispatcher()->vkGetPhysicalDeviceSurfaceSupportKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
+                                                               queueFamilyIndex,
+                                                               static_cast<VkSurfaceKHR>( surface ),
+                                                               reinterpret_cast<VkBool32 *>( &supported ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceSupportKHR" );
+      }
+      return supported;
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR
+      PhysicalDevice::getSurfaceCapabilitiesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkGetPhysicalDeviceSurfaceCapabilitiesKHR &&
+        "Function <vkGetPhysicalDeviceSurfaceCapabilitiesKHR> needs extension <VK_KHR_surface> enabled!" );
+
+      VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR surfaceCapabilities;
+      VULKAN_HPP_NAMESPACE::Result                 result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
+          static_cast<VkPhysicalDevice>( m_physicalDevice ),
+          static_cast<VkSurfaceKHR>( surface ),
+          reinterpret_cast<VkSurfaceCapabilitiesKHR *>( &surfaceCapabilities ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilitiesKHR" );
+      }
+      return surfaceCapabilities;
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR>
+      PhysicalDevice::getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceSurfaceFormatsKHR &&
+                         "Function <vkGetPhysicalDeviceSurfaceFormatsKHR> needs extension <VK_KHR_surface> enabled!" );
+
+      std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR> surfaceFormats;
+      uint32_t                                            surfaceFormatCount;
+      VULKAN_HPP_NAMESPACE::Result                        result;
+      do
+      {
+        result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
+          getDispatcher()->vkGetPhysicalDeviceSurfaceFormatsKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
+                                                                 static_cast<VkSurfaceKHR>( surface ),
+                                                                 &surfaceFormatCount,
+                                                                 nullptr ) );
+        if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && surfaceFormatCount )
+        {
+          surfaceFormats.resize( surfaceFormatCount );
+          result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceSurfaceFormatsKHR(
+            static_cast<VkPhysicalDevice>( m_physicalDevice ),
+            static_cast<VkSurfaceKHR>( surface ),
+            &surfaceFormatCount,
+            reinterpret_cast<VkSurfaceFormatKHR *>( surfaceFormats.data() ) ) );
+          VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() );
+        }
+      } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
+      if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( surfaceFormatCount < surfaceFormats.size() ) )
+      {
+        surfaceFormats.resize( surfaceFormatCount );
+      }
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceFormatsKHR" );
+      }
+      return surfaceFormats;
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR>
+      PhysicalDevice::getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkGetPhysicalDeviceSurfacePresentModesKHR &&
+        "Function <vkGetPhysicalDeviceSurfacePresentModesKHR> needs extension <VK_KHR_surface> enabled!" );
+
+      std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR> presentModes;
+      uint32_t                                          presentModeCount;
+      VULKAN_HPP_NAMESPACE::Result                      result;
+      do
+      {
+        result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
+          getDispatcher()->vkGetPhysicalDeviceSurfacePresentModesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
+                                                                      static_cast<VkSurfaceKHR>( surface ),
+                                                                      &presentModeCount,
+                                                                      nullptr ) );
+        if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && presentModeCount )
+        {
+          presentModes.resize( presentModeCount );
+          result =
+            static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceSurfacePresentModesKHR(
+              static_cast<VkPhysicalDevice>( m_physicalDevice ),
+              static_cast<VkSurfaceKHR>( surface ),
+              &presentModeCount,
+              reinterpret_cast<VkPresentModeKHR *>( presentModes.data() ) ) );
+          VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() );
+        }
+      } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
+      if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( presentModeCount < presentModes.size() ) )
+      {
+        presentModes.resize( presentModeCount );
+      }
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfacePresentModesKHR" );
+      }
+      return presentModes;
+    }
+
+    //=== VK_KHR_swapchain ===
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VkImage> SwapchainKHR::getImages() const
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkGetSwapchainImagesKHR &&
+                         "Function <vkGetSwapchainImagesKHR> needs extension <VK_KHR_swapchain> enabled!" );
+
+      std::vector<VkImage>         swapchainImages;
+      uint32_t                     swapchainImageCount;
+      VULKAN_HPP_NAMESPACE::Result result;
+      do
+      {
+        result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
+          getDispatcher()->vkGetSwapchainImagesKHR( static_cast<VkDevice>( m_device ),
+                                                    static_cast<VkSwapchainKHR>( m_swapchainKHR ),
+                                                    &swapchainImageCount,
+                                                    nullptr ) );
+        if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && swapchainImageCount )
+        {
+          swapchainImages.resize( swapchainImageCount );
+          result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
+            getDispatcher()->vkGetSwapchainImagesKHR( static_cast<VkDevice>( m_device ),
+                                                      static_cast<VkSwapchainKHR>( m_swapchainKHR ),
+                                                      &swapchainImageCount,
+                                                      swapchainImages.data() ) );
+          VULKAN_HPP_ASSERT( swapchainImageCount <= swapchainImages.size() );
+        }
+      } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
+      if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( swapchainImageCount < swapchainImages.size() ) )
+      {
+        swapchainImages.resize( swapchainImageCount );
+      }
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::getImages" );
+      }
+      return swapchainImages;
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<VULKAN_HPP_NAMESPACE::Result, uint32_t>
+                                           SwapchainKHR::acquireNextImage( uint64_t                        timeout,
+                                      VULKAN_HPP_NAMESPACE::Semaphore semaphore,
+                                      VULKAN_HPP_NAMESPACE::Fence     fence ) const
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkAcquireNextImageKHR &&
+                         "Function <vkAcquireNextImageKHR> needs extension <VK_KHR_swapchain> enabled!" );
+
+      uint32_t                     imageIndex;
+      VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
+        getDispatcher()->vkAcquireNextImageKHR( static_cast<VkDevice>( m_device ),
+                                                static_cast<VkSwapchainKHR>( m_swapchainKHR ),
+                                                timeout,
+                                                static_cast<VkSemaphore>( semaphore ),
+                                                static_cast<VkFence>( fence ),
+                                                &imageIndex ) );
+      if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) &&
+           ( result != VULKAN_HPP_NAMESPACE::Result::eTimeout ) &&
+           ( result != VULKAN_HPP_NAMESPACE::Result::eNotReady ) &&
+           ( result != VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR ) )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::acquireNextImage" );
+      }
+      return std::make_pair( result, imageIndex );
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result
+                                           Queue::presentKHR( const PresentInfoKHR & presentInfo ) const
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkQueuePresentKHR &&
+                         "Function <vkQueuePresentKHR> needs extension <VK_KHR_swapchain> enabled!" );
+
+      VULKAN_HPP_NAMESPACE::Result result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkQueuePresentKHR(
+          static_cast<VkQueue>( m_queue ), reinterpret_cast<const VkPresentInfoKHR *>( &presentInfo ) ) );
+      if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) &&
+           ( result != VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR ) )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::presentKHR" );
+      }
+      return result;
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR
+                                           Device::getGroupPresentCapabilitiesKHR() const
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkGetDeviceGroupPresentCapabilitiesKHR &&
+        "Function <vkGetDeviceGroupPresentCapabilitiesKHR> needs extension <VK_KHR_swapchain> enabled!" );
+
+      VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR deviceGroupPresentCapabilities;
+      VULKAN_HPP_NAMESPACE::Result                            result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetDeviceGroupPresentCapabilitiesKHR(
+          static_cast<VkDevice>( m_device ),
+          reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR *>( &deviceGroupPresentCapabilities ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupPresentCapabilitiesKHR" );
+      }
+      return deviceGroupPresentCapabilities;
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR
+      Device::getGroupSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkGetDeviceGroupSurfacePresentModesKHR &&
+        "Function <vkGetDeviceGroupSurfacePresentModesKHR> needs extension <VK_KHR_swapchain> enabled!" );
+
+      VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR modes;
+      VULKAN_HPP_NAMESPACE::Result                         result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetDeviceGroupSurfacePresentModesKHR(
+          static_cast<VkDevice>( m_device ),
+          static_cast<VkSurfaceKHR>( surface ),
+          reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR *>( &modes ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupSurfacePresentModesKHR" );
+      }
+      return modes;
     }
 
     VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::Rect2D>
@@ -8901,33 +10157,863 @@ namespace VULKAN_HPP_NAMESPACE
       return rects;
     }
 
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties
-                                           PhysicalDevice::getProperties() const VULKAN_HPP_NOEXCEPT
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<VULKAN_HPP_NAMESPACE::Result, uint32_t>
+      Device::acquireNextImage2KHR( const AcquireNextImageInfoKHR & acquireInfo ) const
     {
-      VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties properties;
-      getDispatcher()->vkGetPhysicalDeviceProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ),
-                                                      reinterpret_cast<VkPhysicalDeviceProperties *>( &properties ) );
+      VULKAN_HPP_ASSERT( getDispatcher()->vkAcquireNextImage2KHR &&
+                         "Function <vkAcquireNextImage2KHR> needs extension <VK_KHR_swapchain> enabled!" );
+
+      uint32_t                     imageIndex;
+      VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
+        getDispatcher()->vkAcquireNextImage2KHR( static_cast<VkDevice>( m_device ),
+                                                 reinterpret_cast<const VkAcquireNextImageInfoKHR *>( &acquireInfo ),
+                                                 &imageIndex ) );
+      if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) &&
+           ( result != VULKAN_HPP_NAMESPACE::Result::eTimeout ) &&
+           ( result != VULKAN_HPP_NAMESPACE::Result::eNotReady ) &&
+           ( result != VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR ) )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::acquireNextImage2KHR" );
+      }
+      return std::make_pair( result, imageIndex );
+    }
+
+    //=== VK_KHR_display ===
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR>
+                                           PhysicalDevice::getDisplayPropertiesKHR() const
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkGetPhysicalDeviceDisplayPropertiesKHR &&
+        "Function <vkGetPhysicalDeviceDisplayPropertiesKHR> needs extension <VK_KHR_display> enabled!" );
+
+      std::vector<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR> properties;
+      uint32_t                                                propertyCount;
+      VULKAN_HPP_NAMESPACE::Result                            result;
+      do
+      {
+        result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceDisplayPropertiesKHR(
+          static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, nullptr ) );
+        if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount )
+        {
+          properties.resize( propertyCount );
+          result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceDisplayPropertiesKHR(
+            static_cast<VkPhysicalDevice>( m_physicalDevice ),
+            &propertyCount,
+            reinterpret_cast<VkDisplayPropertiesKHR *>( properties.data() ) ) );
+          VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+        }
+      } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
+      if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( propertyCount < properties.size() ) )
+      {
+        properties.resize( propertyCount );
+      }
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPropertiesKHR" );
+      }
       return properties;
     }
 
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2
-                                           PhysicalDevice::getProperties2() const VULKAN_HPP_NOEXCEPT
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR>
+                                           PhysicalDevice::getDisplayPlanePropertiesKHR() const
     {
-      VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 properties;
-      getDispatcher()->vkGetPhysicalDeviceProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ),
-                                                       reinterpret_cast<VkPhysicalDeviceProperties2 *>( &properties ) );
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkGetPhysicalDeviceDisplayPlanePropertiesKHR &&
+        "Function <vkGetPhysicalDeviceDisplayPlanePropertiesKHR> needs extension <VK_KHR_display> enabled!" );
+
+      std::vector<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR> properties;
+      uint32_t                                                     propertyCount;
+      VULKAN_HPP_NAMESPACE::Result                                 result;
+      do
+      {
+        result =
+          static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
+            static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, nullptr ) );
+        if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount )
+        {
+          properties.resize( propertyCount );
+          result =
+            static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
+              static_cast<VkPhysicalDevice>( m_physicalDevice ),
+              &propertyCount,
+              reinterpret_cast<VkDisplayPlanePropertiesKHR *>( properties.data() ) ) );
+          VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+        }
+      } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
+      if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( propertyCount < properties.size() ) )
+      {
+        properties.resize( propertyCount );
+      }
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlanePropertiesKHR" );
+      }
       return properties;
     }
 
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR>
+                                           DisplayKHR::getModeProperties() const
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkGetDisplayModePropertiesKHR &&
+                         "Function <vkGetDisplayModePropertiesKHR> needs extension <VK_KHR_display> enabled!" );
+
+      std::vector<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR> properties;
+      uint32_t                                                    propertyCount;
+      VULKAN_HPP_NAMESPACE::Result                                result;
+      do
+      {
+        result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
+          getDispatcher()->vkGetDisplayModePropertiesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
+                                                          static_cast<VkDisplayKHR>( m_displayKHR ),
+                                                          &propertyCount,
+                                                          nullptr ) );
+        if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount )
+        {
+          properties.resize( propertyCount );
+          result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetDisplayModePropertiesKHR(
+            static_cast<VkPhysicalDevice>( m_physicalDevice ),
+            static_cast<VkDisplayKHR>( m_displayKHR ),
+            &propertyCount,
+            reinterpret_cast<VkDisplayModePropertiesKHR *>( properties.data() ) ) );
+          VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+        }
+      } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
+      if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( propertyCount < properties.size() ) )
+      {
+        properties.resize( propertyCount );
+      }
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::DisplayKHR::getModeProperties" );
+      }
+      return properties;
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR
+                                           DisplayModeKHR::getDisplayPlaneCapabilities( uint32_t planeIndex ) const
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkGetDisplayPlaneCapabilitiesKHR &&
+                         "Function <vkGetDisplayPlaneCapabilitiesKHR> needs extension <VK_KHR_display> enabled!" );
+
+      VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR capabilities;
+      VULKAN_HPP_NAMESPACE::Result                      result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetDisplayPlaneCapabilitiesKHR(
+          static_cast<VkPhysicalDevice>( m_physicalDevice ),
+          static_cast<VkDisplayModeKHR>( m_displayModeKHR ),
+          planeIndex,
+          reinterpret_cast<VkDisplayPlaneCapabilitiesKHR *>( &capabilities ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::DisplayModeKHR::getDisplayPlaneCapabilities" );
+      }
+      return capabilities;
+    }
+
+#  if defined( VK_USE_PLATFORM_XLIB_KHR )
+    //=== VK_KHR_xlib_surface ===
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Bool32 PhysicalDevice::getXlibPresentationSupportKHR(
+      uint32_t queueFamilyIndex, Display & dpy, VisualID visualID ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkGetPhysicalDeviceXlibPresentationSupportKHR &&
+        "Function <vkGetPhysicalDeviceXlibPresentationSupportKHR> needs extension <VK_KHR_xlib_surface> enabled!" );
+
+      return static_cast<VULKAN_HPP_NAMESPACE::Bool32>( getDispatcher()->vkGetPhysicalDeviceXlibPresentationSupportKHR(
+        static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex, &dpy, visualID ) );
+    }
+#  endif /*VK_USE_PLATFORM_XLIB_KHR*/
+
+#  if defined( VK_USE_PLATFORM_XCB_KHR )
+    //=== VK_KHR_xcb_surface ===
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Bool32 PhysicalDevice::getXcbPresentationSupportKHR(
+      uint32_t queueFamilyIndex, xcb_connection_t & connection, xcb_visualid_t visual_id ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkGetPhysicalDeviceXcbPresentationSupportKHR &&
+        "Function <vkGetPhysicalDeviceXcbPresentationSupportKHR> needs extension <VK_KHR_xcb_surface> enabled!" );
+
+      return static_cast<VULKAN_HPP_NAMESPACE::Bool32>( getDispatcher()->vkGetPhysicalDeviceXcbPresentationSupportKHR(
+        static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex, &connection, visual_id ) );
+    }
+#  endif /*VK_USE_PLATFORM_XCB_KHR*/
+
+#  if defined( VK_USE_PLATFORM_WAYLAND_KHR )
+    //=== VK_KHR_wayland_surface ===
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Bool32
+                                           PhysicalDevice::getWaylandPresentationSupportKHR( uint32_t            queueFamilyIndex,
+                                                        struct wl_display & display ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkGetPhysicalDeviceWaylandPresentationSupportKHR &&
+        "Function <vkGetPhysicalDeviceWaylandPresentationSupportKHR> needs extension <VK_KHR_wayland_surface> enabled!" );
+
+      return static_cast<VULKAN_HPP_NAMESPACE::Bool32>(
+        getDispatcher()->vkGetPhysicalDeviceWaylandPresentationSupportKHR(
+          static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex, &display ) );
+    }
+#  endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
+
+#  if defined( VK_USE_PLATFORM_WIN32_KHR )
+    //=== VK_KHR_win32_surface ===
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Bool32
+      PhysicalDevice::getWin32PresentationSupportKHR( uint32_t queueFamilyIndex ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkGetPhysicalDeviceWin32PresentationSupportKHR &&
+        "Function <vkGetPhysicalDeviceWin32PresentationSupportKHR> needs extension <VK_KHR_win32_surface> enabled!" );
+
+      return static_cast<VULKAN_HPP_NAMESPACE::Bool32>( getDispatcher()->vkGetPhysicalDeviceWin32PresentationSupportKHR(
+        static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex ) );
+    }
+#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+    //=== VK_EXT_debug_report ===
+
+    VULKAN_HPP_INLINE void Instance::debugReportMessageEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT      flags,
+                                                            VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType_,
+                                                            uint64_t                                       object,
+                                                            size_t                                         location,
+                                                            int32_t                                        messageCode,
+                                                            const std::string &                            layerPrefix,
+                                                            const std::string & message ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkDebugReportMessageEXT &&
+                         "Function <vkDebugReportMessageEXT> needs extension <VK_EXT_debug_report> enabled!" );
+
+      getDispatcher()->vkDebugReportMessageEXT( static_cast<VkInstance>( m_instance ),
+                                                static_cast<VkDebugReportFlagsEXT>( flags ),
+                                                static_cast<VkDebugReportObjectTypeEXT>( objectType_ ),
+                                                object,
+                                                location,
+                                                messageCode,
+                                                layerPrefix.c_str(),
+                                                message.c_str() );
+    }
+
+    //=== VK_EXT_debug_marker ===
+
+    VULKAN_HPP_INLINE void Device::debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT & tagInfo ) const
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkDebugMarkerSetObjectTagEXT &&
+                         "Function <vkDebugMarkerSetObjectTagEXT> needs extension <VK_EXT_debug_marker> enabled!" );
+
+      VULKAN_HPP_NAMESPACE::Result result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkDebugMarkerSetObjectTagEXT(
+          static_cast<VkDevice>( m_device ), reinterpret_cast<const VkDebugMarkerObjectTagInfoEXT *>( &tagInfo ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::debugMarkerSetObjectTagEXT" );
+      }
+    }
+
+    VULKAN_HPP_INLINE void Device::debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT & nameInfo ) const
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkDebugMarkerSetObjectNameEXT &&
+                         "Function <vkDebugMarkerSetObjectNameEXT> needs extension <VK_EXT_debug_marker> enabled!" );
+
+      VULKAN_HPP_NAMESPACE::Result result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkDebugMarkerSetObjectNameEXT(
+          static_cast<VkDevice>( m_device ), reinterpret_cast<const VkDebugMarkerObjectNameInfoEXT *>( &nameInfo ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::debugMarkerSetObjectNameEXT" );
+      }
+    }
+
+    VULKAN_HPP_INLINE void
+      CommandBuffer::debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT & markerInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDebugMarkerBeginEXT &&
+                         "Function <vkCmdDebugMarkerBeginEXT> needs extension <VK_EXT_debug_marker> enabled!" );
+
+      getDispatcher()->vkCmdDebugMarkerBeginEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                                 reinterpret_cast<const VkDebugMarkerMarkerInfoEXT *>( &markerInfo ) );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::debugMarkerEndEXT() const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDebugMarkerEndEXT &&
+                         "Function <vkCmdDebugMarkerEndEXT> needs extension <VK_EXT_debug_marker> enabled!" );
+
+      getDispatcher()->vkCmdDebugMarkerEndEXT( static_cast<VkCommandBuffer>( m_commandBuffer ) );
+    }
+
+    VULKAN_HPP_INLINE void
+      CommandBuffer::debugMarkerInsertEXT( const DebugMarkerMarkerInfoEXT & markerInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDebugMarkerInsertEXT &&
+                         "Function <vkCmdDebugMarkerInsertEXT> needs extension <VK_EXT_debug_marker> enabled!" );
+
+      getDispatcher()->vkCmdDebugMarkerInsertEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                                  reinterpret_cast<const VkDebugMarkerMarkerInfoEXT *>( &markerInfo ) );
+    }
+
+#  if defined( VK_ENABLE_BETA_EXTENSIONS )
+    //=== VK_KHR_video_queue ===
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR
+      PhysicalDevice::getVideoCapabilitiesKHR( const VideoProfileKHR & videoProfile ) const
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkGetPhysicalDeviceVideoCapabilitiesKHR &&
+        "Function <vkGetPhysicalDeviceVideoCapabilitiesKHR> needs extension <VK_KHR_video_queue> enabled!" );
+
+      VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR capabilities;
+      VULKAN_HPP_NAMESPACE::Result               result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceVideoCapabilitiesKHR(
+          static_cast<VkPhysicalDevice>( m_physicalDevice ),
+          reinterpret_cast<const VkVideoProfileKHR *>( &videoProfile ),
+          reinterpret_cast<VkVideoCapabilitiesKHR *>( &capabilities ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoCapabilitiesKHR" );
+      }
+      return capabilities;
+    }
+
+    template <typename X, typename Y, typename... Z>
+    VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
+                         PhysicalDevice::getVideoCapabilitiesKHR( const VideoProfileKHR & videoProfile ) const
+    {
+      StructureChain<X, Y, Z...>                   structureChain;
+      VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR & capabilities =
+        structureChain.template get<VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR>();
+      VULKAN_HPP_NAMESPACE::Result result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceVideoCapabilitiesKHR(
+          static_cast<VkPhysicalDevice>( m_physicalDevice ),
+          reinterpret_cast<const VkVideoProfileKHR *>( &videoProfile ),
+          reinterpret_cast<VkVideoCapabilitiesKHR *>( &capabilities ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoCapabilitiesKHR" );
+      }
+      return structureChain;
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR>
+      PhysicalDevice::getVideoFormatPropertiesKHR( const PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo ) const
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkGetPhysicalDeviceVideoFormatPropertiesKHR &&
+        "Function <vkGetPhysicalDeviceVideoFormatPropertiesKHR> needs extension <VK_KHR_video_queue> enabled!" );
+
+      std::vector<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR> videoFormatProperties;
+      uint32_t                                                    videoFormatPropertyCount;
+      VULKAN_HPP_NAMESPACE::Result                                result;
+      do
+      {
+        result =
+          static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceVideoFormatPropertiesKHR(
+            static_cast<VkPhysicalDevice>( m_physicalDevice ),
+            reinterpret_cast<const VkPhysicalDeviceVideoFormatInfoKHR *>( &videoFormatInfo ),
+            &videoFormatPropertyCount,
+            nullptr ) );
+        if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && videoFormatPropertyCount )
+        {
+          videoFormatProperties.resize( videoFormatPropertyCount );
+          result =
+            static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceVideoFormatPropertiesKHR(
+              static_cast<VkPhysicalDevice>( m_physicalDevice ),
+              reinterpret_cast<const VkPhysicalDeviceVideoFormatInfoKHR *>( &videoFormatInfo ),
+              &videoFormatPropertyCount,
+              reinterpret_cast<VkVideoFormatPropertiesKHR *>( videoFormatProperties.data() ) ) );
+          VULKAN_HPP_ASSERT( videoFormatPropertyCount <= videoFormatProperties.size() );
+        }
+      } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
+      if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) &&
+           ( videoFormatPropertyCount < videoFormatProperties.size() ) )
+      {
+        videoFormatProperties.resize( videoFormatPropertyCount );
+      }
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoFormatPropertiesKHR" );
+      }
+      return videoFormatProperties;
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::VideoGetMemoryPropertiesKHR>
+                                           VideoSessionKHR::getMemoryRequirements() const
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkGetVideoSessionMemoryRequirementsKHR &&
+        "Function <vkGetVideoSessionMemoryRequirementsKHR> needs extension <VK_KHR_video_queue> enabled!" );
+
+      std::vector<VULKAN_HPP_NAMESPACE::VideoGetMemoryPropertiesKHR> videoSessionMemoryRequirements;
+      uint32_t                                                       videoSessionMemoryRequirementsCount;
+      VULKAN_HPP_NAMESPACE::Result                                   result;
+      do
+      {
+        result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
+          getDispatcher()->vkGetVideoSessionMemoryRequirementsKHR( static_cast<VkDevice>( m_device ),
+                                                                   static_cast<VkVideoSessionKHR>( m_videoSessionKHR ),
+                                                                   &videoSessionMemoryRequirementsCount,
+                                                                   nullptr ) );
+        if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && videoSessionMemoryRequirementsCount )
+        {
+          videoSessionMemoryRequirements.resize( videoSessionMemoryRequirementsCount );
+          result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetVideoSessionMemoryRequirementsKHR(
+            static_cast<VkDevice>( m_device ),
+            static_cast<VkVideoSessionKHR>( m_videoSessionKHR ),
+            &videoSessionMemoryRequirementsCount,
+            reinterpret_cast<VkVideoGetMemoryPropertiesKHR *>( videoSessionMemoryRequirements.data() ) ) );
+          VULKAN_HPP_ASSERT( videoSessionMemoryRequirementsCount <= videoSessionMemoryRequirements.size() );
+        }
+      } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
+      if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) &&
+           ( videoSessionMemoryRequirementsCount < videoSessionMemoryRequirements.size() ) )
+      {
+        videoSessionMemoryRequirements.resize( videoSessionMemoryRequirementsCount );
+      }
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::VideoSessionKHR::getMemoryRequirements" );
+      }
+      return videoSessionMemoryRequirements;
+    }
+
+    VULKAN_HPP_INLINE void VideoSessionKHR::bindMemory(
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::VideoBindMemoryKHR> const & videoSessionBindMemories ) const
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkBindVideoSessionMemoryKHR &&
+                         "Function <vkBindVideoSessionMemoryKHR> needs extension <VK_KHR_video_queue> enabled!" );
+
+      VULKAN_HPP_NAMESPACE::Result result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkBindVideoSessionMemoryKHR(
+          static_cast<VkDevice>( m_device ),
+          static_cast<VkVideoSessionKHR>( m_videoSessionKHR ),
+          videoSessionBindMemories.size(),
+          reinterpret_cast<const VkVideoBindMemoryKHR *>( videoSessionBindMemories.data() ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::VideoSessionKHR::bindMemory" );
+      }
+    }
+
+    VULKAN_HPP_INLINE void
+      VideoSessionParametersKHR::update( const VideoSessionParametersUpdateInfoKHR & updateInfo ) const
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkUpdateVideoSessionParametersKHR &&
+                         "Function <vkUpdateVideoSessionParametersKHR> needs extension <VK_KHR_video_queue> enabled!" );
+
+      VULKAN_HPP_NAMESPACE::Result result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkUpdateVideoSessionParametersKHR(
+          static_cast<VkDevice>( m_device ),
+          static_cast<VkVideoSessionParametersKHR>( m_videoSessionParametersKHR ),
+          reinterpret_cast<const VkVideoSessionParametersUpdateInfoKHR *>( &updateInfo ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::VideoSessionParametersKHR::update" );
+      }
+    }
+
+    VULKAN_HPP_INLINE void
+      CommandBuffer::beginVideoCodingKHR( const VideoBeginCodingInfoKHR & beginInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginVideoCodingKHR &&
+                         "Function <vkCmdBeginVideoCodingKHR> needs extension <VK_KHR_video_queue> enabled!" );
+
+      getDispatcher()->vkCmdBeginVideoCodingKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                                 reinterpret_cast<const VkVideoBeginCodingInfoKHR *>( &beginInfo ) );
+    }
+
+    VULKAN_HPP_INLINE void
+      CommandBuffer::endVideoCodingKHR( const VideoEndCodingInfoKHR & endCodingInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndVideoCodingKHR &&
+                         "Function <vkCmdEndVideoCodingKHR> needs extension <VK_KHR_video_queue> enabled!" );
+
+      getDispatcher()->vkCmdEndVideoCodingKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                               reinterpret_cast<const VkVideoEndCodingInfoKHR *>( &endCodingInfo ) );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::controlVideoCodingKHR(
+      const VideoCodingControlInfoKHR & codingControlInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdControlVideoCodingKHR &&
+                         "Function <vkCmdControlVideoCodingKHR> needs extension <VK_KHR_video_queue> enabled!" );
+
+      getDispatcher()->vkCmdControlVideoCodingKHR(
+        static_cast<VkCommandBuffer>( m_commandBuffer ),
+        reinterpret_cast<const VkVideoCodingControlInfoKHR *>( &codingControlInfo ) );
+    }
+#  endif /*VK_ENABLE_BETA_EXTENSIONS*/
+
+#  if defined( VK_ENABLE_BETA_EXTENSIONS )
+    //=== VK_KHR_video_decode_queue ===
+
+    VULKAN_HPP_INLINE void
+      CommandBuffer::decodeVideoKHR( const VideoDecodeInfoKHR & frameInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDecodeVideoKHR &&
+                         "Function <vkCmdDecodeVideoKHR> needs extension <VK_KHR_video_decode_queue> enabled!" );
+
+      getDispatcher()->vkCmdDecodeVideoKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                            reinterpret_cast<const VkVideoDecodeInfoKHR *>( &frameInfo ) );
+    }
+#  endif /*VK_ENABLE_BETA_EXTENSIONS*/
+
+    //=== VK_EXT_transform_feedback ===
+
+    VULKAN_HPP_INLINE void CommandBuffer::bindTransformFeedbackBuffersEXT(
+      uint32_t                                                   firstBinding,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &     buffers,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkCmdBindTransformFeedbackBuffersEXT &&
+        "Function <vkCmdBindTransformFeedbackBuffersEXT> needs extension <VK_EXT_transform_feedback> enabled!" );
+
+#  ifdef VULKAN_HPP_NO_EXCEPTIONS
+      VULKAN_HPP_ASSERT( buffers.size() == offsets.size() );
+      VULKAN_HPP_ASSERT( sizes.empty() || buffers.size() == sizes.size() );
+#  else
+      if ( buffers.size() != offsets.size() )
+      {
+        throw LogicError( VULKAN_HPP_NAMESPACE_STRING
+                          "::CommandBuffer::bindTransformFeedbackBuffersEXT: buffers.size() != offsets.size()" );
+      }
+      if ( !sizes.empty() && buffers.size() != sizes.size() )
+      {
+        throw LogicError( VULKAN_HPP_NAMESPACE_STRING
+                          "::CommandBuffer::bindTransformFeedbackBuffersEXT: buffers.size() != sizes.size()" );
+      }
+#  endif /*VULKAN_HPP_NO_EXCEPTIONS*/
+
+      getDispatcher()->vkCmdBindTransformFeedbackBuffersEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                                             firstBinding,
+                                                             buffers.size(),
+                                                             reinterpret_cast<const VkBuffer *>( buffers.data() ),
+                                                             reinterpret_cast<const VkDeviceSize *>( offsets.data() ),
+                                                             reinterpret_cast<const VkDeviceSize *>( sizes.data() ) );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::beginTransformFeedbackEXT(
+      uint32_t                                                   firstCounterBuffer,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &     counterBuffers,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets ) const
+      VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkCmdBeginTransformFeedbackEXT &&
+        "Function <vkCmdBeginTransformFeedbackEXT> needs extension <VK_EXT_transform_feedback> enabled!" );
+
+#  ifdef VULKAN_HPP_NO_EXCEPTIONS
+      VULKAN_HPP_ASSERT( counterBufferOffsets.empty() || counterBuffers.size() == counterBufferOffsets.size() );
+#  else
+      if ( !counterBufferOffsets.empty() && counterBuffers.size() != counterBufferOffsets.size() )
+      {
+        throw LogicError(
+          VULKAN_HPP_NAMESPACE_STRING
+          "::CommandBuffer::beginTransformFeedbackEXT: counterBuffers.size() != counterBufferOffsets.size()" );
+      }
+#  endif /*VULKAN_HPP_NO_EXCEPTIONS*/
+
+      getDispatcher()->vkCmdBeginTransformFeedbackEXT(
+        static_cast<VkCommandBuffer>( m_commandBuffer ),
+        firstCounterBuffer,
+        counterBuffers.size(),
+        reinterpret_cast<const VkBuffer *>( counterBuffers.data() ),
+        reinterpret_cast<const VkDeviceSize *>( counterBufferOffsets.data() ) );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::endTransformFeedbackEXT(
+      uint32_t                                                   firstCounterBuffer,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &     counterBuffers,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets ) const
+      VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkCmdEndTransformFeedbackEXT &&
+        "Function <vkCmdEndTransformFeedbackEXT> needs extension <VK_EXT_transform_feedback> enabled!" );
+
+#  ifdef VULKAN_HPP_NO_EXCEPTIONS
+      VULKAN_HPP_ASSERT( counterBufferOffsets.empty() || counterBuffers.size() == counterBufferOffsets.size() );
+#  else
+      if ( !counterBufferOffsets.empty() && counterBuffers.size() != counterBufferOffsets.size() )
+      {
+        throw LogicError(
+          VULKAN_HPP_NAMESPACE_STRING
+          "::CommandBuffer::endTransformFeedbackEXT: counterBuffers.size() != counterBufferOffsets.size()" );
+      }
+#  endif /*VULKAN_HPP_NO_EXCEPTIONS*/
+
+      getDispatcher()->vkCmdEndTransformFeedbackEXT(
+        static_cast<VkCommandBuffer>( m_commandBuffer ),
+        firstCounterBuffer,
+        counterBuffers.size(),
+        reinterpret_cast<const VkBuffer *>( counterBuffers.data() ),
+        reinterpret_cast<const VkDeviceSize *>( counterBufferOffsets.data() ) );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::beginQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool         queryPool,
+                                                                uint32_t                                query,
+                                                                VULKAN_HPP_NAMESPACE::QueryControlFlags flags,
+                                                                uint32_t index ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginQueryIndexedEXT &&
+                         "Function <vkCmdBeginQueryIndexedEXT> needs extension <VK_EXT_transform_feedback> enabled!" );
+
+      getDispatcher()->vkCmdBeginQueryIndexedEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                                  static_cast<VkQueryPool>( queryPool ),
+                                                  query,
+                                                  static_cast<VkQueryControlFlags>( flags ),
+                                                  index );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::endQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
+                                                              uint32_t                        query,
+                                                              uint32_t index ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndQueryIndexedEXT &&
+                         "Function <vkCmdEndQueryIndexedEXT> needs extension <VK_EXT_transform_feedback> enabled!" );
+
+      getDispatcher()->vkCmdEndQueryIndexedEXT(
+        static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkQueryPool>( queryPool ), query, index );
+    }
+
+    VULKAN_HPP_INLINE void
+      CommandBuffer::drawIndirectByteCountEXT( uint32_t                         instanceCount,
+                                               uint32_t                         firstInstance,
+                                               VULKAN_HPP_NAMESPACE::Buffer     counterBuffer,
+                                               VULKAN_HPP_NAMESPACE::DeviceSize counterBufferOffset,
+                                               uint32_t                         counterOffset,
+                                               uint32_t                         vertexStride ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkCmdDrawIndirectByteCountEXT &&
+        "Function <vkCmdDrawIndirectByteCountEXT> needs extension <VK_EXT_transform_feedback> enabled!" );
+
+      getDispatcher()->vkCmdDrawIndirectByteCountEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                                      instanceCount,
+                                                      firstInstance,
+                                                      static_cast<VkBuffer>( counterBuffer ),
+                                                      static_cast<VkDeviceSize>( counterBufferOffset ),
+                                                      counterOffset,
+                                                      vertexStride );
+    }
+
+    //=== VK_NVX_binary_import ===
+
+    VULKAN_HPP_INLINE void
+      CommandBuffer::cuLaunchKernelNVX( const CuLaunchInfoNVX & launchInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCuLaunchKernelNVX &&
+                         "Function <vkCmdCuLaunchKernelNVX> needs extension <VK_NVX_binary_import> enabled!" );
+
+      getDispatcher()->vkCmdCuLaunchKernelNVX( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                               reinterpret_cast<const VkCuLaunchInfoNVX *>( &launchInfo ) );
+    }
+
+    //=== VK_NVX_image_view_handle ===
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint32_t
+      Device::getImageViewHandleNVX( const ImageViewHandleInfoNVX & info ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageViewHandleNVX &&
+                         "Function <vkGetImageViewHandleNVX> needs extension <VK_NVX_image_view_handle> enabled!" );
+
+      return getDispatcher()->vkGetImageViewHandleNVX( static_cast<VkDevice>( m_device ),
+                                                       reinterpret_cast<const VkImageViewHandleInfoNVX *>( &info ) );
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX
+                                           ImageView::getAddressNVX() const
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageViewAddressNVX &&
+                         "Function <vkGetImageViewAddressNVX> needs extension <VK_NVX_image_view_handle> enabled!" );
+
+      VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX properties;
+      VULKAN_HPP_NAMESPACE::Result                        result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetImageViewAddressNVX(
+          static_cast<VkDevice>( m_device ),
+          static_cast<VkImageView>( m_imageView ),
+          reinterpret_cast<VkImageViewAddressPropertiesNVX *>( &properties ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::ImageView::getAddressNVX" );
+      }
+      return properties;
+    }
+
+    //=== VK_AMD_draw_indirect_count ===
+
+    VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer     buffer,
+                                                                VULKAN_HPP_NAMESPACE::DeviceSize offset,
+                                                                VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
+                                                                VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
+                                                                uint32_t                         maxDrawCount,
+                                                                uint32_t stride ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawIndirectCountAMD &&
+                         "Function <vkCmdDrawIndirectCountAMD> needs extension <VK_AMD_draw_indirect_count> enabled!" );
+
+      getDispatcher()->vkCmdDrawIndirectCountAMD( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                                  static_cast<VkBuffer>( buffer ),
+                                                  static_cast<VkDeviceSize>( offset ),
+                                                  static_cast<VkBuffer>( countBuffer ),
+                                                  static_cast<VkDeviceSize>( countBufferOffset ),
+                                                  maxDrawCount,
+                                                  stride );
+    }
+
+    VULKAN_HPP_INLINE void
+      CommandBuffer::drawIndexedIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer     buffer,
+                                                  VULKAN_HPP_NAMESPACE::DeviceSize offset,
+                                                  VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
+                                                  VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
+                                                  uint32_t                         maxDrawCount,
+                                                  uint32_t                         stride ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkCmdDrawIndexedIndirectCountAMD &&
+        "Function <vkCmdDrawIndexedIndirectCountAMD> needs extension <VK_AMD_draw_indirect_count> enabled!" );
+
+      getDispatcher()->vkCmdDrawIndexedIndirectCountAMD( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                                         static_cast<VkBuffer>( buffer ),
+                                                         static_cast<VkDeviceSize>( offset ),
+                                                         static_cast<VkBuffer>( countBuffer ),
+                                                         static_cast<VkDeviceSize>( countBufferOffset ),
+                                                         maxDrawCount,
+                                                         stride );
+    }
+
+    //=== VK_AMD_shader_info ===
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<uint8_t>
+      Pipeline::getShaderInfoAMD( VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage,
+                                  VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD   infoType ) const
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkGetShaderInfoAMD &&
+                         "Function <vkGetShaderInfoAMD> needs extension <VK_AMD_shader_info> enabled!" );
+
+      std::vector<uint8_t>         info;
+      size_t                       infoSize;
+      VULKAN_HPP_NAMESPACE::Result result;
+      do
+      {
+        result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
+          getDispatcher()->vkGetShaderInfoAMD( static_cast<VkDevice>( m_device ),
+                                               static_cast<VkPipeline>( m_pipeline ),
+                                               static_cast<VkShaderStageFlagBits>( shaderStage ),
+                                               static_cast<VkShaderInfoTypeAMD>( infoType ),
+                                               &infoSize,
+                                               nullptr ) );
+        if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && infoSize )
+        {
+          info.resize( infoSize );
+          result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
+            getDispatcher()->vkGetShaderInfoAMD( static_cast<VkDevice>( m_device ),
+                                                 static_cast<VkPipeline>( m_pipeline ),
+                                                 static_cast<VkShaderStageFlagBits>( shaderStage ),
+                                                 static_cast<VkShaderInfoTypeAMD>( infoType ),
+                                                 &infoSize,
+                                                 reinterpret_cast<void *>( info.data() ) ) );
+          VULKAN_HPP_ASSERT( infoSize <= info.size() );
+        }
+      } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
+      if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( infoSize < info.size() ) )
+      {
+        info.resize( infoSize );
+      }
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Pipeline::getShaderInfoAMD" );
+      }
+      return info;
+    }
+
+    //=== VK_NV_external_memory_capabilities ===
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV
+                                           PhysicalDevice::getExternalImageFormatPropertiesNV(
+        VULKAN_HPP_NAMESPACE::Format                          format,
+        VULKAN_HPP_NAMESPACE::ImageType                       type,
+        VULKAN_HPP_NAMESPACE::ImageTiling                     tiling,
+        VULKAN_HPP_NAMESPACE::ImageUsageFlags                 usage,
+        VULKAN_HPP_NAMESPACE::ImageCreateFlags                flags,
+        VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV externalHandleType ) const
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkGetPhysicalDeviceExternalImageFormatPropertiesNV &&
+        "Function <vkGetPhysicalDeviceExternalImageFormatPropertiesNV> needs extension <VK_NV_external_memory_capabilities> enabled!" );
+
+      VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV externalImageFormatProperties;
+      VULKAN_HPP_NAMESPACE::Result                          result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
+          static_cast<VkPhysicalDevice>( m_physicalDevice ),
+          static_cast<VkFormat>( format ),
+          static_cast<VkImageType>( type ),
+          static_cast<VkImageTiling>( tiling ),
+          static_cast<VkImageUsageFlags>( usage ),
+          static_cast<VkImageCreateFlags>( flags ),
+          static_cast<VkExternalMemoryHandleTypeFlagsNV>( externalHandleType ),
+          reinterpret_cast<VkExternalImageFormatPropertiesNV *>( &externalImageFormatProperties ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result,
+                              VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getExternalImageFormatPropertiesNV" );
+      }
+      return externalImageFormatProperties;
+    }
+
+#  if defined( VK_USE_PLATFORM_WIN32_KHR )
+    //=== VK_NV_external_memory_win32 ===
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE HANDLE
+      DeviceMemory::getMemoryWin32HandleNV( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleType ) const
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryWin32HandleNV &&
+                         "Function <vkGetMemoryWin32HandleNV> needs extension <VK_NV_external_memory_win32> enabled!" );
+
+      HANDLE                       handle;
+      VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
+        getDispatcher()->vkGetMemoryWin32HandleNV( static_cast<VkDevice>( m_device ),
+                                                   static_cast<VkDeviceMemory>( m_deviceMemory ),
+                                                   static_cast<VkExternalMemoryHandleTypeFlagsNV>( handleType ),
+                                                   &handle ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::DeviceMemory::getMemoryWin32HandleNV" );
+      }
+      return handle;
+    }
+#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+    //=== VK_KHR_get_physical_device_properties2 ===
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2
+                                           PhysicalDevice::getFeatures2KHR() const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkGetPhysicalDeviceFeatures2KHR &&
+        "Function <vkGetPhysicalDeviceFeatures2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!" );
+
+      VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 features;
+      getDispatcher()->vkGetPhysicalDeviceFeatures2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
+                                                        reinterpret_cast<VkPhysicalDeviceFeatures2 *>( &features ) );
+      return features;
+    }
+
     template <typename X, typename Y, typename... Z>
     VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
-                                           PhysicalDevice::getProperties2() const VULKAN_HPP_NOEXCEPT
+                                           PhysicalDevice::getFeatures2KHR() const VULKAN_HPP_NOEXCEPT
     {
-      StructureChain<X, Y, Z...>                        structureChain;
-      VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 & properties =
-        structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2>();
-      getDispatcher()->vkGetPhysicalDeviceProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ),
-                                                       reinterpret_cast<VkPhysicalDeviceProperties2 *>( &properties ) );
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkGetPhysicalDeviceFeatures2KHR &&
+        "Function <vkGetPhysicalDeviceFeatures2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!" );
+
+      StructureChain<X, Y, Z...>                      structureChain;
+      VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 & features =
+        structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2>();
+      getDispatcher()->vkGetPhysicalDeviceFeatures2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
+                                                        reinterpret_cast<VkPhysicalDeviceFeatures2 *>( &features ) );
       return structureChain;
     }
 
@@ -8962,74 +11048,76 @@ namespace VULKAN_HPP_NAMESPACE
       return structureChain;
     }
 
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint32_t PhysicalDevice::getQueueFamilyPerformanceQueryPassesKHR(
-      const QueryPoolPerformanceCreateInfoKHR & performanceQueryCreateInfo ) const VULKAN_HPP_NOEXCEPT
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::FormatProperties2
+      PhysicalDevice::getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format ) const VULKAN_HPP_NOEXCEPT
     {
       VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR &&
-        "Function <vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR> needs extension <VK_KHR_performance_query> enabled!" );
+        getDispatcher()->vkGetPhysicalDeviceFormatProperties2KHR &&
+        "Function <vkGetPhysicalDeviceFormatProperties2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!" );
 
-      uint32_t numPasses;
-      getDispatcher()->vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(
+      VULKAN_HPP_NAMESPACE::FormatProperties2 formatProperties;
+      getDispatcher()->vkGetPhysicalDeviceFormatProperties2KHR(
         static_cast<VkPhysicalDevice>( m_physicalDevice ),
-        reinterpret_cast<const VkQueryPoolPerformanceCreateInfoKHR *>( &performanceQueryCreateInfo ),
-        &numPasses );
-      return numPasses;
+        static_cast<VkFormat>( format ),
+        reinterpret_cast<VkFormatProperties2 *>( &formatProperties ) );
+      return formatProperties;
     }
 
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties>
-                                           PhysicalDevice::getQueueFamilyProperties() const VULKAN_HPP_NOEXCEPT
+    template <typename X, typename Y, typename... Z>
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
+      PhysicalDevice::getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format ) const VULKAN_HPP_NOEXCEPT
     {
-      uint32_t queueFamilyPropertyCount;
-      getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties(
-        static_cast<VkPhysicalDevice>( m_physicalDevice ), &queueFamilyPropertyCount, nullptr );
-      std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties> queueFamilyProperties( queueFamilyPropertyCount );
-      getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties(
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkGetPhysicalDeviceFormatProperties2KHR &&
+        "Function <vkGetPhysicalDeviceFormatProperties2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!" );
+
+      StructureChain<X, Y, Z...>                structureChain;
+      VULKAN_HPP_NAMESPACE::FormatProperties2 & formatProperties =
+        structureChain.template get<VULKAN_HPP_NAMESPACE::FormatProperties2>();
+      getDispatcher()->vkGetPhysicalDeviceFormatProperties2KHR(
         static_cast<VkPhysicalDevice>( m_physicalDevice ),
-        &queueFamilyPropertyCount,
-        reinterpret_cast<VkQueueFamilyProperties *>( queueFamilyProperties.data() ) );
-      VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() );
-      return queueFamilyProperties;
+        static_cast<VkFormat>( format ),
+        reinterpret_cast<VkFormatProperties2 *>( &formatProperties ) );
+      return structureChain;
     }
 
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>
-                                           PhysicalDevice::getQueueFamilyProperties2() const VULKAN_HPP_NOEXCEPT
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ImageFormatProperties2
+      PhysicalDevice::getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const
     {
-      uint32_t queueFamilyPropertyCount;
-      getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2(
-        static_cast<VkPhysicalDevice>( m_physicalDevice ), &queueFamilyPropertyCount, nullptr );
-      std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> queueFamilyProperties( queueFamilyPropertyCount );
-      getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2(
-        static_cast<VkPhysicalDevice>( m_physicalDevice ),
-        &queueFamilyPropertyCount,
-        reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) );
-      VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() );
-      return queueFamilyProperties;
-    }
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2KHR &&
+        "Function <vkGetPhysicalDeviceImageFormatProperties2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!" );
 
-    template <typename StructureChain>
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<StructureChain> PhysicalDevice::getQueueFamilyProperties2() const
-    {
-      uint32_t queueFamilyPropertyCount;
-      getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2(
-        static_cast<VkPhysicalDevice>( m_physicalDevice ), &queueFamilyPropertyCount, nullptr );
-      std::vector<StructureChain>                               returnVector( queueFamilyPropertyCount );
-      std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> queueFamilyProperties( queueFamilyPropertyCount );
-      for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ )
+      VULKAN_HPP_NAMESPACE::ImageFormatProperties2 imageFormatProperties;
+      VULKAN_HPP_NAMESPACE::Result                 result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2KHR(
+          static_cast<VkPhysicalDevice>( m_physicalDevice ),
+          reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( &imageFormatInfo ),
+          reinterpret_cast<VkImageFormatProperties2 *>( &imageFormatProperties ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
       {
-        queueFamilyProperties[i].pNext =
-          returnVector[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>().pNext;
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2KHR" );
       }
-      getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2(
-        static_cast<VkPhysicalDevice>( m_physicalDevice ),
-        &queueFamilyPropertyCount,
-        reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) );
-      VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() );
-      for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ )
+      return imageFormatProperties;
+    }
+
+    template <typename X, typename Y, typename... Z>
+    VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
+      PhysicalDevice::getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const
+    {
+      StructureChain<X, Y, Z...>                     structureChain;
+      VULKAN_HPP_NAMESPACE::ImageFormatProperties2 & imageFormatProperties =
+        structureChain.template get<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>();
+      VULKAN_HPP_NAMESPACE::Result result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2KHR(
+          static_cast<VkPhysicalDevice>( m_physicalDevice ),
+          reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( &imageFormatInfo ),
+          reinterpret_cast<VkImageFormatProperties2 *>( &imageFormatProperties ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
       {
-        returnVector[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>() = queueFamilyProperties[i];
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2KHR" );
       }
-      return returnVector;
+      return structureChain;
     }
 
     VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>
@@ -9081,71 +11169,35 @@ namespace VULKAN_HPP_NAMESPACE
       return returnVector;
     }
 
-#  if defined( VK_USE_PLATFORM_SCREEN_QNX )
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Bool32
-                                           PhysicalDevice::getScreenPresentationSupportQNX( uint32_t                queueFamilyIndex,
-                                                       struct _screen_window & window ) const VULKAN_HPP_NOEXCEPT
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2
+                                           PhysicalDevice::getMemoryProperties2KHR() const VULKAN_HPP_NOEXCEPT
     {
       VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetPhysicalDeviceScreenPresentationSupportQNX &&
-        "Function <vkGetPhysicalDeviceScreenPresentationSupportQNX> needs extension <VK_QNX_screen_surface> enabled!" );
+        getDispatcher()->vkGetPhysicalDeviceMemoryProperties2KHR &&
+        "Function <vkGetPhysicalDeviceMemoryProperties2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!" );
 
-      return static_cast<VULKAN_HPP_NAMESPACE::Bool32>(
-        getDispatcher()->vkGetPhysicalDeviceScreenPresentationSupportQNX(
-          static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex, &window ) );
-    }
-#  endif /*VK_USE_PLATFORM_SCREEN_QNX*/
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties>
-      PhysicalDevice::getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format              format,
-                                                      VULKAN_HPP_NAMESPACE::ImageType           type,
-                                                      VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,
-                                                      VULKAN_HPP_NAMESPACE::ImageUsageFlags     usage,
-                                                      VULKAN_HPP_NAMESPACE::ImageTiling         tiling ) const
-      VULKAN_HPP_NOEXCEPT
-    {
-      uint32_t propertyCount;
-      getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties(
+      VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 memoryProperties;
+      getDispatcher()->vkGetPhysicalDeviceMemoryProperties2KHR(
         static_cast<VkPhysicalDevice>( m_physicalDevice ),
-        static_cast<VkFormat>( format ),
-        static_cast<VkImageType>( type ),
-        static_cast<VkSampleCountFlagBits>( samples ),
-        static_cast<VkImageUsageFlags>( usage ),
-        static_cast<VkImageTiling>( tiling ),
-        &propertyCount,
-        nullptr );
-      std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties> properties( propertyCount );
-      getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties(
-        static_cast<VkPhysicalDevice>( m_physicalDevice ),
-        static_cast<VkFormat>( format ),
-        static_cast<VkImageType>( type ),
-        static_cast<VkSampleCountFlagBits>( samples ),
-        static_cast<VkImageUsageFlags>( usage ),
-        static_cast<VkImageTiling>( tiling ),
-        &propertyCount,
-        reinterpret_cast<VkSparseImageFormatProperties *>( properties.data() ) );
-      VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
-      return properties;
+        reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( &memoryProperties ) );
+      return memoryProperties;
     }
 
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>
-      PhysicalDevice::getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo ) const
-      VULKAN_HPP_NOEXCEPT
+    template <typename X, typename Y, typename... Z>
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
+                                           PhysicalDevice::getMemoryProperties2KHR() const VULKAN_HPP_NOEXCEPT
     {
-      uint32_t propertyCount;
-      getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties2(
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkGetPhysicalDeviceMemoryProperties2KHR &&
+        "Function <vkGetPhysicalDeviceMemoryProperties2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!" );
+
+      StructureChain<X, Y, Z...>                              structureChain;
+      VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 & memoryProperties =
+        structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2>();
+      getDispatcher()->vkGetPhysicalDeviceMemoryProperties2KHR(
         static_cast<VkPhysicalDevice>( m_physicalDevice ),
-        reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ),
-        &propertyCount,
-        nullptr );
-      std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2> properties( propertyCount );
-      getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties2(
-        static_cast<VkPhysicalDevice>( m_physicalDevice ),
-        reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ),
-        &propertyCount,
-        reinterpret_cast<VkSparseImageFormatProperties2 *>( properties.data() ) );
-      VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
-      return properties;
+        reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( &memoryProperties ) );
+      return structureChain;
     }
 
     VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>
@@ -9172,44 +11224,432 @@ namespace VULKAN_HPP_NAMESPACE
       return properties;
     }
 
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV>
-                                           PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV() const
+    //=== VK_KHR_device_group ===
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags
+                                           Device::getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex,
+                                             uint32_t localDeviceIndex,
+                                             uint32_t remoteDeviceIndex ) const VULKAN_HPP_NOEXCEPT
     {
       VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV &&
-        "Function <vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV> needs extension <VK_NV_coverage_reduction_mode> enabled!" );
+        getDispatcher()->vkGetDeviceGroupPeerMemoryFeaturesKHR &&
+        "Function <vkGetDeviceGroupPeerMemoryFeaturesKHR> needs extension <VK_KHR_device_group> enabled!" );
 
-      std::vector<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV> combinations;
-      uint32_t                                                                combinationCount;
-      VULKAN_HPP_NAMESPACE::Result                                            result;
+      VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags peerMemoryFeatures;
+      getDispatcher()->vkGetDeviceGroupPeerMemoryFeaturesKHR(
+        static_cast<VkDevice>( m_device ),
+        heapIndex,
+        localDeviceIndex,
+        remoteDeviceIndex,
+        reinterpret_cast<VkPeerMemoryFeatureFlags *>( &peerMemoryFeatures ) );
+      return peerMemoryFeatures;
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::setDeviceMaskKHR( uint32_t deviceMask ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDeviceMaskKHR &&
+                         "Function <vkCmdSetDeviceMaskKHR> needs extension <VK_KHR_device_group> enabled!" );
+
+      getDispatcher()->vkCmdSetDeviceMaskKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), deviceMask );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::dispatchBaseKHR( uint32_t baseGroupX,
+                                                           uint32_t baseGroupY,
+                                                           uint32_t baseGroupZ,
+                                                           uint32_t groupCountX,
+                                                           uint32_t groupCountY,
+                                                           uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDispatchBaseKHR &&
+                         "Function <vkCmdDispatchBaseKHR> needs extension <VK_KHR_device_group> enabled!" );
+
+      getDispatcher()->vkCmdDispatchBaseKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                             baseGroupX,
+                                             baseGroupY,
+                                             baseGroupZ,
+                                             groupCountX,
+                                             groupCountY,
+                                             groupCountZ );
+    }
+
+    //=== VK_KHR_maintenance1 ===
+
+    VULKAN_HPP_INLINE void
+      CommandPool::trimKHR( VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkTrimCommandPoolKHR &&
+                         "Function <vkTrimCommandPoolKHR> needs extension <VK_KHR_maintenance1> enabled!" );
+
+      getDispatcher()->vkTrimCommandPoolKHR( static_cast<VkDevice>( m_device ),
+                                             static_cast<VkCommandPool>( m_commandPool ),
+                                             static_cast<VkCommandPoolTrimFlags>( flags ) );
+    }
+
+    //=== VK_KHR_device_group_creation ===
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>
+                                           Instance::enumeratePhysicalDeviceGroupsKHR() const
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkEnumeratePhysicalDeviceGroupsKHR &&
+        "Function <vkEnumeratePhysicalDeviceGroupsKHR> needs extension <VK_KHR_device_group_creation> enabled!" );
+
+      std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties> physicalDeviceGroupProperties;
+      uint32_t                                                         physicalDeviceGroupCount;
+      VULKAN_HPP_NAMESPACE::Result                                     result;
       do
       {
-        result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-          getDispatcher()->vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
-            static_cast<VkPhysicalDevice>( m_physicalDevice ), &combinationCount, nullptr ) );
-        if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && combinationCount )
+        result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkEnumeratePhysicalDeviceGroupsKHR(
+          static_cast<VkInstance>( m_instance ), &physicalDeviceGroupCount, nullptr ) );
+        if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && physicalDeviceGroupCount )
         {
-          combinations.resize( combinationCount );
-          result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-            getDispatcher()->vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
-              static_cast<VkPhysicalDevice>( m_physicalDevice ),
-              &combinationCount,
-              reinterpret_cast<VkFramebufferMixedSamplesCombinationNV *>( combinations.data() ) ) );
-          VULKAN_HPP_ASSERT( combinationCount <= combinations.size() );
+          physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
+          result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkEnumeratePhysicalDeviceGroupsKHR(
+            static_cast<VkInstance>( m_instance ),
+            &physicalDeviceGroupCount,
+            reinterpret_cast<VkPhysicalDeviceGroupProperties *>( physicalDeviceGroupProperties.data() ) ) );
+          VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() );
         }
       } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
-      if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( combinationCount < combinations.size() ) )
+      if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) &&
+           ( physicalDeviceGroupCount < physicalDeviceGroupProperties.size() ) )
       {
-        combinations.resize( combinationCount );
+        physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
       }
       if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
       {
-        throwResultException(
-          result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV" );
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDeviceGroupsKHR" );
       }
-      return combinations;
+      return physicalDeviceGroupProperties;
     }
 
+    //=== VK_KHR_external_memory_capabilities ===
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalBufferProperties
+                                           PhysicalDevice::getExternalBufferPropertiesKHR(
+        const PhysicalDeviceExternalBufferInfo & externalBufferInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkGetPhysicalDeviceExternalBufferPropertiesKHR &&
+        "Function <vkGetPhysicalDeviceExternalBufferPropertiesKHR> needs extension <VK_KHR_external_memory_capabilities> enabled!" );
+
+      VULKAN_HPP_NAMESPACE::ExternalBufferProperties externalBufferProperties;
+      getDispatcher()->vkGetPhysicalDeviceExternalBufferPropertiesKHR(
+        static_cast<VkPhysicalDevice>( m_physicalDevice ),
+        reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo *>( &externalBufferInfo ),
+        reinterpret_cast<VkExternalBufferProperties *>( &externalBufferProperties ) );
+      return externalBufferProperties;
+    }
+
+#  if defined( VK_USE_PLATFORM_WIN32_KHR )
+    //=== VK_KHR_external_memory_win32 ===
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE HANDLE
+      Device::getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR & getWin32HandleInfo ) const
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkGetMemoryWin32HandleKHR &&
+        "Function <vkGetMemoryWin32HandleKHR> needs extension <VK_KHR_external_memory_win32> enabled!" );
+
+      HANDLE                       handle;
+      VULKAN_HPP_NAMESPACE::Result result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetMemoryWin32HandleKHR(
+          static_cast<VkDevice>( m_device ),
+          reinterpret_cast<const VkMemoryGetWin32HandleInfoKHR *>( &getWin32HandleInfo ),
+          &handle ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryWin32HandleKHR" );
+      }
+      return handle;
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR
+      Device::getMemoryWin32HandlePropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
+                                                 HANDLE                                                 handle ) const
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkGetMemoryWin32HandlePropertiesKHR &&
+        "Function <vkGetMemoryWin32HandlePropertiesKHR> needs extension <VK_KHR_external_memory_win32> enabled!" );
+
+      VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR memoryWin32HandleProperties;
+      VULKAN_HPP_NAMESPACE::Result                         result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetMemoryWin32HandlePropertiesKHR(
+          static_cast<VkDevice>( m_device ),
+          static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ),
+          handle,
+          reinterpret_cast<VkMemoryWin32HandlePropertiesKHR *>( &memoryWin32HandleProperties ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryWin32HandlePropertiesKHR" );
+      }
+      return memoryWin32HandleProperties;
+    }
+#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+    //=== VK_KHR_external_memory_fd ===
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE int Device::getMemoryFdKHR( const MemoryGetFdInfoKHR & getFdInfo ) const
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryFdKHR &&
+                         "Function <vkGetMemoryFdKHR> needs extension <VK_KHR_external_memory_fd> enabled!" );
+
+      int                          fd;
+      VULKAN_HPP_NAMESPACE::Result result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetMemoryFdKHR(
+          static_cast<VkDevice>( m_device ), reinterpret_cast<const VkMemoryGetFdInfoKHR *>( &getFdInfo ), &fd ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryFdKHR" );
+      }
+      return fd;
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR
+      Device::getMemoryFdPropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
+                                        int                                                    fd ) const
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryFdPropertiesKHR &&
+                         "Function <vkGetMemoryFdPropertiesKHR> needs extension <VK_KHR_external_memory_fd> enabled!" );
+
+      VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR memoryFdProperties;
+      VULKAN_HPP_NAMESPACE::Result                result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetMemoryFdPropertiesKHR(
+          static_cast<VkDevice>( m_device ),
+          static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ),
+          fd,
+          reinterpret_cast<VkMemoryFdPropertiesKHR *>( &memoryFdProperties ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryFdPropertiesKHR" );
+      }
+      return memoryFdProperties;
+    }
+
+    //=== VK_KHR_external_semaphore_capabilities ===
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties
+                                           PhysicalDevice::getExternalSemaphorePropertiesKHR(
+        const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkGetPhysicalDeviceExternalSemaphorePropertiesKHR &&
+        "Function <vkGetPhysicalDeviceExternalSemaphorePropertiesKHR> needs extension <VK_KHR_external_semaphore_capabilities> enabled!" );
+
+      VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties externalSemaphoreProperties;
+      getDispatcher()->vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
+        static_cast<VkPhysicalDevice>( m_physicalDevice ),
+        reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo *>( &externalSemaphoreInfo ),
+        reinterpret_cast<VkExternalSemaphoreProperties *>( &externalSemaphoreProperties ) );
+      return externalSemaphoreProperties;
+    }
+
+#  if defined( VK_USE_PLATFORM_WIN32_KHR )
+    //=== VK_KHR_external_semaphore_win32 ===
+
+    VULKAN_HPP_INLINE void Device::importSemaphoreWin32HandleKHR(
+      const ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo ) const
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkImportSemaphoreWin32HandleKHR &&
+        "Function <vkImportSemaphoreWin32HandleKHR> needs extension <VK_KHR_external_semaphore_win32> enabled!" );
+
+      VULKAN_HPP_NAMESPACE::Result result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkImportSemaphoreWin32HandleKHR(
+          static_cast<VkDevice>( m_device ),
+          reinterpret_cast<const VkImportSemaphoreWin32HandleInfoKHR *>( &importSemaphoreWin32HandleInfo ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importSemaphoreWin32HandleKHR" );
+      }
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE HANDLE
+      Device::getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo ) const
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkGetSemaphoreWin32HandleKHR &&
+        "Function <vkGetSemaphoreWin32HandleKHR> needs extension <VK_KHR_external_semaphore_win32> enabled!" );
+
+      HANDLE                       handle;
+      VULKAN_HPP_NAMESPACE::Result result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetSemaphoreWin32HandleKHR(
+          static_cast<VkDevice>( m_device ),
+          reinterpret_cast<const VkSemaphoreGetWin32HandleInfoKHR *>( &getWin32HandleInfo ),
+          &handle ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreWin32HandleKHR" );
+      }
+      return handle;
+    }
+#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+    //=== VK_KHR_external_semaphore_fd ===
+
+    VULKAN_HPP_INLINE void Device::importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo ) const
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkImportSemaphoreFdKHR &&
+                         "Function <vkImportSemaphoreFdKHR> needs extension <VK_KHR_external_semaphore_fd> enabled!" );
+
+      VULKAN_HPP_NAMESPACE::Result result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkImportSemaphoreFdKHR(
+          static_cast<VkDevice>( m_device ),
+          reinterpret_cast<const VkImportSemaphoreFdInfoKHR *>( &importSemaphoreFdInfo ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importSemaphoreFdKHR" );
+      }
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE int
+      Device::getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR & getFdInfo ) const
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkGetSemaphoreFdKHR &&
+                         "Function <vkGetSemaphoreFdKHR> needs extension <VK_KHR_external_semaphore_fd> enabled!" );
+
+      int                          fd;
+      VULKAN_HPP_NAMESPACE::Result result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetSemaphoreFdKHR(
+          static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSemaphoreGetFdInfoKHR *>( &getFdInfo ), &fd ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreFdKHR" );
+      }
+      return fd;
+    }
+
+    //=== VK_KHR_push_descriptor ===
+
+    VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetKHR(
+      VULKAN_HPP_NAMESPACE::PipelineBindPoint                            pipelineBindPoint,
+      VULKAN_HPP_NAMESPACE::PipelineLayout                               layout,
+      uint32_t                                                           set,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdPushDescriptorSetKHR &&
+                         "Function <vkCmdPushDescriptorSetKHR> needs extension <VK_KHR_push_descriptor> enabled!" );
+
+      getDispatcher()->vkCmdPushDescriptorSetKHR(
+        static_cast<VkCommandBuffer>( m_commandBuffer ),
+        static_cast<VkPipelineBindPoint>( pipelineBindPoint ),
+        static_cast<VkPipelineLayout>( layout ),
+        set,
+        descriptorWrites.size(),
+        reinterpret_cast<const VkWriteDescriptorSet *>( descriptorWrites.data() ) );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplateKHR(
+      VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
+      VULKAN_HPP_NAMESPACE::PipelineLayout           layout,
+      uint32_t                                       set,
+      const void *                                   pData ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkCmdPushDescriptorSetWithTemplateKHR &&
+        "Function <vkCmdPushDescriptorSetWithTemplateKHR> needs extension <VK_KHR_push_descriptor> enabled!" );
+
+      getDispatcher()->vkCmdPushDescriptorSetWithTemplateKHR(
+        static_cast<VkCommandBuffer>( m_commandBuffer ),
+        static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
+        static_cast<VkPipelineLayout>( layout ),
+        set,
+        pData );
+    }
+
+    //=== VK_EXT_conditional_rendering ===
+
+    VULKAN_HPP_INLINE void CommandBuffer::beginConditionalRenderingEXT(
+      const ConditionalRenderingBeginInfoEXT & conditionalRenderingBegin ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkCmdBeginConditionalRenderingEXT &&
+        "Function <vkCmdBeginConditionalRenderingEXT> needs extension <VK_EXT_conditional_rendering> enabled!" );
+
+      getDispatcher()->vkCmdBeginConditionalRenderingEXT(
+        static_cast<VkCommandBuffer>( m_commandBuffer ),
+        reinterpret_cast<const VkConditionalRenderingBeginInfoEXT *>( &conditionalRenderingBegin ) );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::endConditionalRenderingEXT() const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkCmdEndConditionalRenderingEXT &&
+        "Function <vkCmdEndConditionalRenderingEXT> needs extension <VK_EXT_conditional_rendering> enabled!" );
+
+      getDispatcher()->vkCmdEndConditionalRenderingEXT( static_cast<VkCommandBuffer>( m_commandBuffer ) );
+    }
+
+    //=== VK_KHR_descriptor_update_template ===
+
+    VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplateKHR(
+      VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
+      Optional<const AllocationCallbacks>            allocator ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkDestroyDescriptorUpdateTemplateKHR &&
+        "Function <vkDestroyDescriptorUpdateTemplateKHR> needs extension <VK_KHR_descriptor_update_template> enabled!" );
+
+      getDispatcher()->vkDestroyDescriptorUpdateTemplateKHR(
+        static_cast<VkDevice>( m_device ),
+        static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
+        reinterpret_cast<const VkAllocationCallbacks *>(
+          static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+    }
+
+    VULKAN_HPP_INLINE void
+      DescriptorSet::updateWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
+                                            const void * pData ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkUpdateDescriptorSetWithTemplateKHR &&
+        "Function <vkUpdateDescriptorSetWithTemplateKHR> needs extension <VK_KHR_descriptor_update_template> enabled!" );
+
+      getDispatcher()->vkUpdateDescriptorSetWithTemplateKHR(
+        static_cast<VkDevice>( m_device ),
+        static_cast<VkDescriptorSet>( m_descriptorSet ),
+        static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
+        pData );
+    }
+
+    //=== VK_NV_clip_space_w_scaling ===
+
+    VULKAN_HPP_INLINE void CommandBuffer::setViewportWScalingNV(
+      uint32_t                                                           firstViewport,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::ViewportWScalingNV> const & viewportWScalings ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkCmdSetViewportWScalingNV &&
+        "Function <vkCmdSetViewportWScalingNV> needs extension <VK_NV_clip_space_w_scaling> enabled!" );
+
+      getDispatcher()->vkCmdSetViewportWScalingNV(
+        static_cast<VkCommandBuffer>( m_commandBuffer ),
+        firstViewport,
+        viewportWScalings.size(),
+        reinterpret_cast<const VkViewportWScalingNV *>( viewportWScalings.data() ) );
+    }
+
+#  if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
+    //=== VK_EXT_acquire_xlib_display ===
+
+    VULKAN_HPP_INLINE void PhysicalDevice::acquireXlibDisplayEXT( Display &                        dpy,
+                                                                  VULKAN_HPP_NAMESPACE::DisplayKHR display ) const
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkAcquireXlibDisplayEXT &&
+                         "Function <vkAcquireXlibDisplayEXT> needs extension <VK_EXT_acquire_xlib_display> enabled!" );
+
+      VULKAN_HPP_NAMESPACE::Result result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkAcquireXlibDisplayEXT(
+          static_cast<VkPhysicalDevice>( m_physicalDevice ), &dpy, static_cast<VkDisplayKHR>( display ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::acquireXlibDisplayEXT" );
+      }
+    }
+#  endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
+
+    //=== VK_EXT_display_surface_counter ===
+
     VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT
       PhysicalDevice::getSurfaceCapabilities2EXT( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const
     {
@@ -9230,6 +11670,378 @@ namespace VULKAN_HPP_NAMESPACE
       return surfaceCapabilities;
     }
 
+    //=== VK_EXT_display_control ===
+
+    VULKAN_HPP_INLINE void Device::displayPowerControlEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display,
+                                                           const DisplayPowerInfoEXT &      displayPowerInfo ) const
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkDisplayPowerControlEXT &&
+                         "Function <vkDisplayPowerControlEXT> needs extension <VK_EXT_display_control> enabled!" );
+
+      VULKAN_HPP_NAMESPACE::Result result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkDisplayPowerControlEXT(
+          static_cast<VkDevice>( m_device ),
+          static_cast<VkDisplayKHR>( display ),
+          reinterpret_cast<const VkDisplayPowerInfoEXT *>( &displayPowerInfo ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::displayPowerControlEXT" );
+      }
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t
+      SwapchainKHR::getCounterEXT( VULKAN_HPP_NAMESPACE::SurfaceCounterFlagBitsEXT counter ) const
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkGetSwapchainCounterEXT &&
+                         "Function <vkGetSwapchainCounterEXT> needs extension <VK_EXT_display_control> enabled!" );
+
+      uint64_t                     counterValue;
+      VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
+        getDispatcher()->vkGetSwapchainCounterEXT( static_cast<VkDevice>( m_device ),
+                                                   static_cast<VkSwapchainKHR>( m_swapchainKHR ),
+                                                   static_cast<VkSurfaceCounterFlagBitsEXT>( counter ),
+                                                   &counterValue ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::getCounterEXT" );
+      }
+      return counterValue;
+    }
+
+    //=== VK_GOOGLE_display_timing ===
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE
+                                           SwapchainKHR::getRefreshCycleDurationGOOGLE() const
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkGetRefreshCycleDurationGOOGLE &&
+        "Function <vkGetRefreshCycleDurationGOOGLE> needs extension <VK_GOOGLE_display_timing> enabled!" );
+
+      VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE displayTimingProperties;
+      VULKAN_HPP_NAMESPACE::Result                     result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetRefreshCycleDurationGOOGLE(
+          static_cast<VkDevice>( m_device ),
+          static_cast<VkSwapchainKHR>( m_swapchainKHR ),
+          reinterpret_cast<VkRefreshCycleDurationGOOGLE *>( &displayTimingProperties ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::getRefreshCycleDurationGOOGLE" );
+      }
+      return displayTimingProperties;
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE>
+                                           SwapchainKHR::getPastPresentationTimingGOOGLE() const
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkGetPastPresentationTimingGOOGLE &&
+        "Function <vkGetPastPresentationTimingGOOGLE> needs extension <VK_GOOGLE_display_timing> enabled!" );
+
+      std::vector<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE> presentationTimings;
+      uint32_t                                                        presentationTimingCount;
+      VULKAN_HPP_NAMESPACE::Result                                    result;
+      do
+      {
+        result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
+          getDispatcher()->vkGetPastPresentationTimingGOOGLE( static_cast<VkDevice>( m_device ),
+                                                              static_cast<VkSwapchainKHR>( m_swapchainKHR ),
+                                                              &presentationTimingCount,
+                                                              nullptr ) );
+        if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && presentationTimingCount )
+        {
+          presentationTimings.resize( presentationTimingCount );
+          result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPastPresentationTimingGOOGLE(
+            static_cast<VkDevice>( m_device ),
+            static_cast<VkSwapchainKHR>( m_swapchainKHR ),
+            &presentationTimingCount,
+            reinterpret_cast<VkPastPresentationTimingGOOGLE *>( presentationTimings.data() ) ) );
+          VULKAN_HPP_ASSERT( presentationTimingCount <= presentationTimings.size() );
+        }
+      } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
+      if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) &&
+           ( presentationTimingCount < presentationTimings.size() ) )
+      {
+        presentationTimings.resize( presentationTimingCount );
+      }
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::getPastPresentationTimingGOOGLE" );
+      }
+      return presentationTimings;
+    }
+
+    //=== VK_EXT_discard_rectangles ===
+
+    VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleEXT(
+      uint32_t                                               firstDiscardRectangle,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & discardRectangles ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkCmdSetDiscardRectangleEXT &&
+        "Function <vkCmdSetDiscardRectangleEXT> needs extension <VK_EXT_discard_rectangles> enabled!" );
+
+      getDispatcher()->vkCmdSetDiscardRectangleEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                                    firstDiscardRectangle,
+                                                    discardRectangles.size(),
+                                                    reinterpret_cast<const VkRect2D *>( discardRectangles.data() ) );
+    }
+
+    //=== VK_EXT_hdr_metadata ===
+
+    VULKAN_HPP_INLINE void
+      Device::setHdrMetadataEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainKHR> const &   swapchains,
+                                 ArrayProxy<const VULKAN_HPP_NAMESPACE::HdrMetadataEXT> const & metadata ) const
+      VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkSetHdrMetadataEXT &&
+                         "Function <vkSetHdrMetadataEXT> needs extension <VK_EXT_hdr_metadata> enabled!" );
+
+#  ifdef VULKAN_HPP_NO_EXCEPTIONS
+      VULKAN_HPP_ASSERT( swapchains.size() == metadata.size() );
+#  else
+      if ( swapchains.size() != metadata.size() )
+      {
+        throw LogicError( VULKAN_HPP_NAMESPACE_STRING
+                          "::Device::setHdrMetadataEXT: swapchains.size() != metadata.size()" );
+      }
+#  endif /*VULKAN_HPP_NO_EXCEPTIONS*/
+
+      getDispatcher()->vkSetHdrMetadataEXT( static_cast<VkDevice>( m_device ),
+                                            swapchains.size(),
+                                            reinterpret_cast<const VkSwapchainKHR *>( swapchains.data() ),
+                                            reinterpret_cast<const VkHdrMetadataEXT *>( metadata.data() ) );
+    }
+
+    //=== VK_KHR_create_renderpass2 ===
+
+    VULKAN_HPP_INLINE void
+      CommandBuffer::beginRenderPass2KHR( const RenderPassBeginInfo & renderPassBegin,
+                                          const SubpassBeginInfo &    subpassBeginInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginRenderPass2KHR &&
+                         "Function <vkCmdBeginRenderPass2KHR> needs extension <VK_KHR_create_renderpass2> enabled!" );
+
+      getDispatcher()->vkCmdBeginRenderPass2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                                 reinterpret_cast<const VkRenderPassBeginInfo *>( &renderPassBegin ),
+                                                 reinterpret_cast<const VkSubpassBeginInfo *>( &subpassBeginInfo ) );
+    }
+
+    VULKAN_HPP_INLINE void
+      CommandBuffer::nextSubpass2KHR( const SubpassBeginInfo & subpassBeginInfo,
+                                      const SubpassEndInfo &   subpassEndInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdNextSubpass2KHR &&
+                         "Function <vkCmdNextSubpass2KHR> needs extension <VK_KHR_create_renderpass2> enabled!" );
+
+      getDispatcher()->vkCmdNextSubpass2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                             reinterpret_cast<const VkSubpassBeginInfo *>( &subpassBeginInfo ),
+                                             reinterpret_cast<const VkSubpassEndInfo *>( &subpassEndInfo ) );
+    }
+
+    VULKAN_HPP_INLINE void
+      CommandBuffer::endRenderPass2KHR( const SubpassEndInfo & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndRenderPass2KHR &&
+                         "Function <vkCmdEndRenderPass2KHR> needs extension <VK_KHR_create_renderpass2> enabled!" );
+
+      getDispatcher()->vkCmdEndRenderPass2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                               reinterpret_cast<const VkSubpassEndInfo *>( &subpassEndInfo ) );
+    }
+
+    //=== VK_KHR_shared_presentable_image ===
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result SwapchainKHR::getStatus() const
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkGetSwapchainStatusKHR &&
+        "Function <vkGetSwapchainStatusKHR> needs extension <VK_KHR_shared_presentable_image> enabled!" );
+
+      VULKAN_HPP_NAMESPACE::Result result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetSwapchainStatusKHR(
+          static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchainKHR ) ) );
+      if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) &&
+           ( result != VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR ) )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::getStatus" );
+      }
+      return result;
+    }
+
+    //=== VK_KHR_external_fence_capabilities ===
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalFenceProperties
+      PhysicalDevice::getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfo & externalFenceInfo ) const
+      VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkGetPhysicalDeviceExternalFencePropertiesKHR &&
+        "Function <vkGetPhysicalDeviceExternalFencePropertiesKHR> needs extension <VK_KHR_external_fence_capabilities> enabled!" );
+
+      VULKAN_HPP_NAMESPACE::ExternalFenceProperties externalFenceProperties;
+      getDispatcher()->vkGetPhysicalDeviceExternalFencePropertiesKHR(
+        static_cast<VkPhysicalDevice>( m_physicalDevice ),
+        reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo *>( &externalFenceInfo ),
+        reinterpret_cast<VkExternalFenceProperties *>( &externalFenceProperties ) );
+      return externalFenceProperties;
+    }
+
+#  if defined( VK_USE_PLATFORM_WIN32_KHR )
+    //=== VK_KHR_external_fence_win32 ===
+
+    VULKAN_HPP_INLINE void
+      Device::importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo ) const
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkImportFenceWin32HandleKHR &&
+        "Function <vkImportFenceWin32HandleKHR> needs extension <VK_KHR_external_fence_win32> enabled!" );
+
+      VULKAN_HPP_NAMESPACE::Result result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkImportFenceWin32HandleKHR(
+          static_cast<VkDevice>( m_device ),
+          reinterpret_cast<const VkImportFenceWin32HandleInfoKHR *>( &importFenceWin32HandleInfo ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importFenceWin32HandleKHR" );
+      }
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE HANDLE
+      Device::getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR & getWin32HandleInfo ) const
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkGetFenceWin32HandleKHR &&
+                         "Function <vkGetFenceWin32HandleKHR> needs extension <VK_KHR_external_fence_win32> enabled!" );
+
+      HANDLE                       handle;
+      VULKAN_HPP_NAMESPACE::Result result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetFenceWin32HandleKHR(
+          static_cast<VkDevice>( m_device ),
+          reinterpret_cast<const VkFenceGetWin32HandleInfoKHR *>( &getWin32HandleInfo ),
+          &handle ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getFenceWin32HandleKHR" );
+      }
+      return handle;
+    }
+#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+    //=== VK_KHR_external_fence_fd ===
+
+    VULKAN_HPP_INLINE void Device::importFenceFdKHR( const ImportFenceFdInfoKHR & importFenceFdInfo ) const
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkImportFenceFdKHR &&
+                         "Function <vkImportFenceFdKHR> needs extension <VK_KHR_external_fence_fd> enabled!" );
+
+      VULKAN_HPP_NAMESPACE::Result result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkImportFenceFdKHR(
+          static_cast<VkDevice>( m_device ), reinterpret_cast<const VkImportFenceFdInfoKHR *>( &importFenceFdInfo ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importFenceFdKHR" );
+      }
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE int Device::getFenceFdKHR( const FenceGetFdInfoKHR & getFdInfo ) const
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkGetFenceFdKHR &&
+                         "Function <vkGetFenceFdKHR> needs extension <VK_KHR_external_fence_fd> enabled!" );
+
+      int                          fd;
+      VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetFenceFdKHR(
+        static_cast<VkDevice>( m_device ), reinterpret_cast<const VkFenceGetFdInfoKHR *>( &getFdInfo ), &fd ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getFenceFdKHR" );
+      }
+      return fd;
+    }
+
+    //=== VK_KHR_performance_query ===
+
+    VULKAN_HPP_NODISCARD
+      VULKAN_HPP_INLINE std::pair<std::vector<PerformanceCounterKHR>, std::vector<PerformanceCounterDescriptionKHR>>
+      PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex ) const
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR &&
+        "Function <vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR> needs extension <VK_KHR_performance_query> enabled!" );
+
+      std::pair<std::vector<PerformanceCounterKHR>, std::vector<PerformanceCounterDescriptionKHR>> data;
+      std::vector<PerformanceCounterKHR> &            counters            = data.first;
+      std::vector<PerformanceCounterDescriptionKHR> & counterDescriptions = data.second;
+      uint32_t                                        counterCount;
+      VULKAN_HPP_NAMESPACE::Result                    result;
+      do
+      {
+        result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
+          getDispatcher()->vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
+            static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex, &counterCount, nullptr, nullptr ) );
+        if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && counterCount )
+        {
+          counters.resize( counterCount );
+          counterDescriptions.resize( counterCount );
+          result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
+            getDispatcher()->vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
+              static_cast<VkPhysicalDevice>( m_physicalDevice ),
+              queueFamilyIndex,
+              &counterCount,
+              reinterpret_cast<VkPerformanceCounterKHR *>( counters.data() ),
+              reinterpret_cast<VkPerformanceCounterDescriptionKHR *>( counterDescriptions.data() ) ) );
+          VULKAN_HPP_ASSERT( counterCount <= counters.size() );
+        }
+      } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
+      if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( counterCount < counters.size() ) )
+      {
+        counters.resize( counterCount );
+        counterDescriptions.resize( counterCount );
+      }
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException(
+          result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR" );
+      }
+      return data;
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint32_t PhysicalDevice::getQueueFamilyPerformanceQueryPassesKHR(
+      const QueryPoolPerformanceCreateInfoKHR & performanceQueryCreateInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR &&
+        "Function <vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR> needs extension <VK_KHR_performance_query> enabled!" );
+
+      uint32_t numPasses;
+      getDispatcher()->vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(
+        static_cast<VkPhysicalDevice>( m_physicalDevice ),
+        reinterpret_cast<const VkQueryPoolPerformanceCreateInfoKHR *>( &performanceQueryCreateInfo ),
+        &numPasses );
+      return numPasses;
+    }
+
+    VULKAN_HPP_INLINE void Device::acquireProfilingLockKHR( const AcquireProfilingLockInfoKHR & info ) const
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkAcquireProfilingLockKHR &&
+                         "Function <vkAcquireProfilingLockKHR> needs extension <VK_KHR_performance_query> enabled!" );
+
+      VULKAN_HPP_NAMESPACE::Result result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkAcquireProfilingLockKHR(
+          static_cast<VkDevice>( m_device ), reinterpret_cast<const VkAcquireProfilingLockInfoKHR *>( &info ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::acquireProfilingLockKHR" );
+      }
+    }
+
+    VULKAN_HPP_INLINE void Device::releaseProfilingLockKHR() const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkReleaseProfilingLockKHR &&
+                         "Function <vkReleaseProfilingLockKHR> needs extension <VK_KHR_performance_query> enabled!" );
+
+      getDispatcher()->vkReleaseProfilingLockKHR( static_cast<VkDevice>( m_device ) );
+    }
+
+    //=== VK_KHR_get_surface_capabilities2 ===
+
     VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR
       PhysicalDevice::getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const
     {
@@ -9269,26 +12081,6 @@ namespace VULKAN_HPP_NAMESPACE
       return structureChain;
     }
 
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR
-      PhysicalDevice::getSurfaceCapabilitiesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetPhysicalDeviceSurfaceCapabilitiesKHR &&
-        "Function <vkGetPhysicalDeviceSurfaceCapabilitiesKHR> needs extension <VK_KHR_surface> enabled!" );
-
-      VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR surfaceCapabilities;
-      VULKAN_HPP_NAMESPACE::Result                 result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
-          static_cast<VkPhysicalDevice>( m_physicalDevice ),
-          static_cast<VkSurfaceKHR>( surface ),
-          reinterpret_cast<VkSurfaceCapabilitiesKHR *>( &surfaceCapabilities ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilitiesKHR" );
-      }
-      return surfaceCapabilities;
-    }
-
     VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR>
       PhysicalDevice::getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const
     {
@@ -9328,431 +12120,497 @@ namespace VULKAN_HPP_NAMESPACE
       return surfaceFormats;
     }
 
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR>
-      PhysicalDevice::getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceSurfaceFormatsKHR &&
-                         "Function <vkGetPhysicalDeviceSurfaceFormatsKHR> needs extension <VK_KHR_surface> enabled!" );
+    //=== VK_KHR_get_display_properties2 ===
 
-      std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR> surfaceFormats;
-      uint32_t                                            surfaceFormatCount;
-      VULKAN_HPP_NAMESPACE::Result                        result;
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR>
+                                           PhysicalDevice::getDisplayProperties2KHR() const
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkGetPhysicalDeviceDisplayProperties2KHR &&
+        "Function <vkGetPhysicalDeviceDisplayProperties2KHR> needs extension <VK_KHR_get_display_properties2> enabled!" );
+
+      std::vector<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR> properties;
+      uint32_t                                                 propertyCount;
+      VULKAN_HPP_NAMESPACE::Result                             result;
       do
       {
-        result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-          getDispatcher()->vkGetPhysicalDeviceSurfaceFormatsKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
-                                                                 static_cast<VkSurfaceKHR>( surface ),
-                                                                 &surfaceFormatCount,
-                                                                 nullptr ) );
-        if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && surfaceFormatCount )
+        result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceDisplayProperties2KHR(
+          static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, nullptr ) );
+        if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount )
         {
-          surfaceFormats.resize( surfaceFormatCount );
-          result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceSurfaceFormatsKHR(
+          properties.resize( propertyCount );
+          result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceDisplayProperties2KHR(
             static_cast<VkPhysicalDevice>( m_physicalDevice ),
-            static_cast<VkSurfaceKHR>( surface ),
-            &surfaceFormatCount,
-            reinterpret_cast<VkSurfaceFormatKHR *>( surfaceFormats.data() ) ) );
-          VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() );
+            &propertyCount,
+            reinterpret_cast<VkDisplayProperties2KHR *>( properties.data() ) ) );
+          VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
         }
       } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
-      if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( surfaceFormatCount < surfaceFormats.size() ) )
+      if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( propertyCount < properties.size() ) )
       {
-        surfaceFormats.resize( surfaceFormatCount );
+        properties.resize( propertyCount );
       }
       if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
       {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceFormatsKHR" );
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayProperties2KHR" );
       }
-      return surfaceFormats;
+      return properties;
     }
 
-#  if defined( VK_USE_PLATFORM_WIN32_KHR )
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR>
-      PhysicalDevice::getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR>
+                                           PhysicalDevice::getDisplayPlaneProperties2KHR() const
     {
       VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetPhysicalDeviceSurfacePresentModes2EXT &&
-        "Function <vkGetPhysicalDeviceSurfacePresentModes2EXT> needs extension <VK_EXT_full_screen_exclusive> enabled!" );
+        getDispatcher()->vkGetPhysicalDeviceDisplayPlaneProperties2KHR &&
+        "Function <vkGetPhysicalDeviceDisplayPlaneProperties2KHR> needs extension <VK_KHR_get_display_properties2> enabled!" );
 
-      std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR> presentModes;
-      uint32_t                                          presentModeCount;
-      VULKAN_HPP_NAMESPACE::Result                      result;
-      do
-      {
-        result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceSurfacePresentModes2EXT(
-          static_cast<VkPhysicalDevice>( m_physicalDevice ),
-          reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
-          &presentModeCount,
-          nullptr ) );
-        if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && presentModeCount )
-        {
-          presentModes.resize( presentModeCount );
-          result =
-            static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceSurfacePresentModes2EXT(
-              static_cast<VkPhysicalDevice>( m_physicalDevice ),
-              reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
-              &presentModeCount,
-              reinterpret_cast<VkPresentModeKHR *>( presentModes.data() ) ) );
-          VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() );
-        }
-      } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
-      if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( presentModeCount < presentModes.size() ) )
-      {
-        presentModes.resize( presentModeCount );
-      }
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfacePresentModes2EXT" );
-      }
-      return presentModes;
-    }
-#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR>
-      PhysicalDevice::getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetPhysicalDeviceSurfacePresentModesKHR &&
-        "Function <vkGetPhysicalDeviceSurfacePresentModesKHR> needs extension <VK_KHR_surface> enabled!" );
-
-      std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR> presentModes;
-      uint32_t                                          presentModeCount;
-      VULKAN_HPP_NAMESPACE::Result                      result;
-      do
-      {
-        result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-          getDispatcher()->vkGetPhysicalDeviceSurfacePresentModesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
-                                                                      static_cast<VkSurfaceKHR>( surface ),
-                                                                      &presentModeCount,
-                                                                      nullptr ) );
-        if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && presentModeCount )
-        {
-          presentModes.resize( presentModeCount );
-          result =
-            static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceSurfacePresentModesKHR(
-              static_cast<VkPhysicalDevice>( m_physicalDevice ),
-              static_cast<VkSurfaceKHR>( surface ),
-              &presentModeCount,
-              reinterpret_cast<VkPresentModeKHR *>( presentModes.data() ) ) );
-          VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() );
-        }
-      } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
-      if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( presentModeCount < presentModes.size() ) )
-      {
-        presentModes.resize( presentModeCount );
-      }
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfacePresentModesKHR" );
-      }
-      return presentModes;
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Bool32
-      PhysicalDevice::getSurfaceSupportKHR( uint32_t queueFamilyIndex, VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceSurfaceSupportKHR &&
-                         "Function <vkGetPhysicalDeviceSurfaceSupportKHR> needs extension <VK_KHR_surface> enabled!" );
-
-      VULKAN_HPP_NAMESPACE::Bool32 supported;
-      VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-        getDispatcher()->vkGetPhysicalDeviceSurfaceSupportKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
-                                                               queueFamilyIndex,
-                                                               static_cast<VkSurfaceKHR>( surface ),
-                                                               reinterpret_cast<VkBool32 *>( &supported ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceSupportKHR" );
-      }
-      return supported;
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolPropertiesEXT>
-                                           PhysicalDevice::getToolPropertiesEXT() const
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetPhysicalDeviceToolPropertiesEXT &&
-        "Function <vkGetPhysicalDeviceToolPropertiesEXT> needs extension <VK_EXT_tooling_info> enabled!" );
-
-      std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolPropertiesEXT> toolProperties;
-      uint32_t                                                           toolCount;
-      VULKAN_HPP_NAMESPACE::Result                                       result;
-      do
-      {
-        result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceToolPropertiesEXT(
-          static_cast<VkPhysicalDevice>( m_physicalDevice ), &toolCount, nullptr ) );
-        if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && toolCount )
-        {
-          toolProperties.resize( toolCount );
-          result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceToolPropertiesEXT(
-            static_cast<VkPhysicalDevice>( m_physicalDevice ),
-            &toolCount,
-            reinterpret_cast<VkPhysicalDeviceToolPropertiesEXT *>( toolProperties.data() ) ) );
-          VULKAN_HPP_ASSERT( toolCount <= toolProperties.size() );
-        }
-      } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
-      if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( toolCount < toolProperties.size() ) )
-      {
-        toolProperties.resize( toolCount );
-      }
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getToolPropertiesEXT" );
-      }
-      return toolProperties;
-    }
-
-#  if defined( VK_ENABLE_BETA_EXTENSIONS )
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR
-      PhysicalDevice::getVideoCapabilitiesKHR( const VideoProfileKHR & videoProfile ) const
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetPhysicalDeviceVideoCapabilitiesKHR &&
-        "Function <vkGetPhysicalDeviceVideoCapabilitiesKHR> needs extension <VK_KHR_video_queue> enabled!" );
-
-      VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR capabilities;
-      VULKAN_HPP_NAMESPACE::Result               result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceVideoCapabilitiesKHR(
-          static_cast<VkPhysicalDevice>( m_physicalDevice ),
-          reinterpret_cast<const VkVideoProfileKHR *>( &videoProfile ),
-          reinterpret_cast<VkVideoCapabilitiesKHR *>( &capabilities ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoCapabilitiesKHR" );
-      }
-      return capabilities;
-    }
-#  endif /*VK_ENABLE_BETA_EXTENSIONS*/
-
-#  if defined( VK_ENABLE_BETA_EXTENSIONS )
-    template <typename X, typename Y, typename... Z>
-    VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
-                         PhysicalDevice::getVideoCapabilitiesKHR( const VideoProfileKHR & videoProfile ) const
-    {
-      StructureChain<X, Y, Z...>                   structureChain;
-      VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR & capabilities =
-        structureChain.template get<VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR>();
-      VULKAN_HPP_NAMESPACE::Result result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceVideoCapabilitiesKHR(
-          static_cast<VkPhysicalDevice>( m_physicalDevice ),
-          reinterpret_cast<const VkVideoProfileKHR *>( &videoProfile ),
-          reinterpret_cast<VkVideoCapabilitiesKHR *>( &capabilities ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoCapabilitiesKHR" );
-      }
-      return structureChain;
-    }
-#  endif /*VK_ENABLE_BETA_EXTENSIONS*/
-
-#  if defined( VK_ENABLE_BETA_EXTENSIONS )
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR>
-      PhysicalDevice::getVideoFormatPropertiesKHR( const PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo ) const
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetPhysicalDeviceVideoFormatPropertiesKHR &&
-        "Function <vkGetPhysicalDeviceVideoFormatPropertiesKHR> needs extension <VK_KHR_video_queue> enabled!" );
-
-      std::vector<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR> videoFormatProperties;
-      uint32_t                                                    videoFormatPropertyCount;
-      VULKAN_HPP_NAMESPACE::Result                                result;
+      std::vector<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR> properties;
+      uint32_t                                                      propertyCount;
+      VULKAN_HPP_NAMESPACE::Result                                  result;
       do
       {
         result =
-          static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceVideoFormatPropertiesKHR(
-            static_cast<VkPhysicalDevice>( m_physicalDevice ),
-            reinterpret_cast<const VkPhysicalDeviceVideoFormatInfoKHR *>( &videoFormatInfo ),
-            &videoFormatPropertyCount,
-            nullptr ) );
-        if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && videoFormatPropertyCount )
+          static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceDisplayPlaneProperties2KHR(
+            static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, nullptr ) );
+        if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount )
         {
-          videoFormatProperties.resize( videoFormatPropertyCount );
+          properties.resize( propertyCount );
           result =
-            static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceVideoFormatPropertiesKHR(
+            static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceDisplayPlaneProperties2KHR(
               static_cast<VkPhysicalDevice>( m_physicalDevice ),
-              reinterpret_cast<const VkPhysicalDeviceVideoFormatInfoKHR *>( &videoFormatInfo ),
-              &videoFormatPropertyCount,
-              reinterpret_cast<VkVideoFormatPropertiesKHR *>( videoFormatProperties.data() ) ) );
-          VULKAN_HPP_ASSERT( videoFormatPropertyCount <= videoFormatProperties.size() );
+              &propertyCount,
+              reinterpret_cast<VkDisplayPlaneProperties2KHR *>( properties.data() ) ) );
+          VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
         }
       } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
-      if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) &&
-           ( videoFormatPropertyCount < videoFormatProperties.size() ) )
+      if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( propertyCount < properties.size() ) )
       {
-        videoFormatProperties.resize( videoFormatPropertyCount );
+        properties.resize( propertyCount );
       }
       if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
       {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoFormatPropertiesKHR" );
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneProperties2KHR" );
       }
-      return videoFormatProperties;
+      return properties;
     }
-#  endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
-#  if defined( VK_USE_PLATFORM_WAYLAND_KHR )
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Bool32
-                                           PhysicalDevice::getWaylandPresentationSupportKHR( uint32_t            queueFamilyIndex,
-                                                        struct wl_display & display ) const VULKAN_HPP_NOEXCEPT
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR>
+                                           DisplayKHR::getModeProperties2() const
     {
       VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetPhysicalDeviceWaylandPresentationSupportKHR &&
-        "Function <vkGetPhysicalDeviceWaylandPresentationSupportKHR> needs extension <VK_KHR_wayland_surface> enabled!" );
+        getDispatcher()->vkGetDisplayModeProperties2KHR &&
+        "Function <vkGetDisplayModeProperties2KHR> needs extension <VK_KHR_get_display_properties2> enabled!" );
 
-      return static_cast<VULKAN_HPP_NAMESPACE::Bool32>(
-        getDispatcher()->vkGetPhysicalDeviceWaylandPresentationSupportKHR(
-          static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex, &display ) );
-    }
-#  endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
-
-#  if defined( VK_USE_PLATFORM_WIN32_KHR )
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Bool32
-      PhysicalDevice::getWin32PresentationSupportKHR( uint32_t queueFamilyIndex ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetPhysicalDeviceWin32PresentationSupportKHR &&
-        "Function <vkGetPhysicalDeviceWin32PresentationSupportKHR> needs extension <VK_KHR_win32_surface> enabled!" );
-
-      return static_cast<VULKAN_HPP_NAMESPACE::Bool32>( getDispatcher()->vkGetPhysicalDeviceWin32PresentationSupportKHR(
-        static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex ) );
-    }
-#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#  if defined( VK_USE_PLATFORM_XCB_KHR )
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Bool32 PhysicalDevice::getXcbPresentationSupportKHR(
-      uint32_t queueFamilyIndex, xcb_connection_t & connection, xcb_visualid_t visual_id ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetPhysicalDeviceXcbPresentationSupportKHR &&
-        "Function <vkGetPhysicalDeviceXcbPresentationSupportKHR> needs extension <VK_KHR_xcb_surface> enabled!" );
-
-      return static_cast<VULKAN_HPP_NAMESPACE::Bool32>( getDispatcher()->vkGetPhysicalDeviceXcbPresentationSupportKHR(
-        static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex, &connection, visual_id ) );
-    }
-#  endif /*VK_USE_PLATFORM_XCB_KHR*/
-
-#  if defined( VK_USE_PLATFORM_XLIB_KHR )
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Bool32 PhysicalDevice::getXlibPresentationSupportKHR(
-      uint32_t queueFamilyIndex, Display & dpy, VisualID visualID ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetPhysicalDeviceXlibPresentationSupportKHR &&
-        "Function <vkGetPhysicalDeviceXlibPresentationSupportKHR> needs extension <VK_KHR_xlib_surface> enabled!" );
-
-      return static_cast<VULKAN_HPP_NAMESPACE::Bool32>( getDispatcher()->vkGetPhysicalDeviceXlibPresentationSupportKHR(
-        static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex, &dpy, visualID ) );
-    }
-#  endif /*VK_USE_PLATFORM_XLIB_KHR*/
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<VULKAN_HPP_NAMESPACE::Result, uint32_t>
-      Device::acquireNextImage2KHR( const AcquireNextImageInfoKHR & acquireInfo ) const
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkAcquireNextImage2KHR &&
-                         "Function <vkAcquireNextImage2KHR> needs extension <VK_KHR_swapchain> enabled!" );
-
-      uint32_t                     imageIndex;
-      VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-        getDispatcher()->vkAcquireNextImage2KHR( static_cast<VkDevice>( m_device ),
-                                                 reinterpret_cast<const VkAcquireNextImageInfoKHR *>( &acquireInfo ),
-                                                 &imageIndex ) );
-      if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) &&
-           ( result != VULKAN_HPP_NAMESPACE::Result::eTimeout ) &&
-           ( result != VULKAN_HPP_NAMESPACE::Result::eNotReady ) &&
-           ( result != VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR ) )
+      std::vector<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR> properties;
+      uint32_t                                                     propertyCount;
+      VULKAN_HPP_NAMESPACE::Result                                 result;
+      do
       {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::acquireNextImage2KHR" );
+        result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
+          getDispatcher()->vkGetDisplayModeProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
+                                                           static_cast<VkDisplayKHR>( m_displayKHR ),
+                                                           &propertyCount,
+                                                           nullptr ) );
+        if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount )
+        {
+          properties.resize( propertyCount );
+          result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetDisplayModeProperties2KHR(
+            static_cast<VkPhysicalDevice>( m_physicalDevice ),
+            static_cast<VkDisplayKHR>( m_displayKHR ),
+            &propertyCount,
+            reinterpret_cast<VkDisplayModeProperties2KHR *>( properties.data() ) ) );
+          VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+        }
+      } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
+      if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( propertyCount < properties.size() ) )
+      {
+        properties.resize( propertyCount );
       }
-      return std::make_pair( result, imageIndex );
-    }
-
-    VULKAN_HPP_INLINE void Device::acquireProfilingLockKHR( const AcquireProfilingLockInfoKHR & info ) const
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkAcquireProfilingLockKHR &&
-                         "Function <vkAcquireProfilingLockKHR> needs extension <VK_KHR_performance_query> enabled!" );
-
-      VULKAN_HPP_NAMESPACE::Result result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkAcquireProfilingLockKHR(
-          static_cast<VkDevice>( m_device ), reinterpret_cast<const VkAcquireProfilingLockInfoKHR *>( &info ) ) );
       if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
       {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::acquireProfilingLockKHR" );
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::DisplayKHR::getModeProperties2" );
+      }
+      return properties;
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR
+      PhysicalDevice::getDisplayPlaneCapabilities2KHR( const DisplayPlaneInfo2KHR & displayPlaneInfo ) const
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkGetDisplayPlaneCapabilities2KHR &&
+        "Function <vkGetDisplayPlaneCapabilities2KHR> needs extension <VK_KHR_get_display_properties2> enabled!" );
+
+      VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR capabilities;
+      VULKAN_HPP_NAMESPACE::Result                       result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetDisplayPlaneCapabilities2KHR(
+          static_cast<VkPhysicalDevice>( m_physicalDevice ),
+          reinterpret_cast<const VkDisplayPlaneInfo2KHR *>( &displayPlaneInfo ),
+          reinterpret_cast<VkDisplayPlaneCapabilities2KHR *>( &capabilities ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneCapabilities2KHR" );
+      }
+      return capabilities;
+    }
+
+    //=== VK_EXT_debug_utils ===
+
+    VULKAN_HPP_INLINE void Device::setDebugUtilsObjectNameEXT( const DebugUtilsObjectNameInfoEXT & nameInfo ) const
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkSetDebugUtilsObjectNameEXT &&
+                         "Function <vkSetDebugUtilsObjectNameEXT> needs extension <VK_EXT_debug_utils> enabled!" );
+
+      VULKAN_HPP_NAMESPACE::Result result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkSetDebugUtilsObjectNameEXT(
+          static_cast<VkDevice>( m_device ), reinterpret_cast<const VkDebugUtilsObjectNameInfoEXT *>( &nameInfo ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setDebugUtilsObjectNameEXT" );
       }
     }
 
-    VULKAN_HPP_INLINE void Device::bindAccelerationStructureMemoryNV(
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV> const & bindInfos ) const
+    VULKAN_HPP_INLINE void Device::setDebugUtilsObjectTagEXT( const DebugUtilsObjectTagInfoEXT & tagInfo ) const
     {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkBindAccelerationStructureMemoryNV &&
-        "Function <vkBindAccelerationStructureMemoryNV> needs extension <VK_NV_ray_tracing> enabled!" );
+      VULKAN_HPP_ASSERT( getDispatcher()->vkSetDebugUtilsObjectTagEXT &&
+                         "Function <vkSetDebugUtilsObjectTagEXT> needs extension <VK_EXT_debug_utils> enabled!" );
 
       VULKAN_HPP_NAMESPACE::Result result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkBindAccelerationStructureMemoryNV(
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkSetDebugUtilsObjectTagEXT(
+          static_cast<VkDevice>( m_device ), reinterpret_cast<const VkDebugUtilsObjectTagInfoEXT *>( &tagInfo ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setDebugUtilsObjectTagEXT" );
+      }
+    }
+
+    VULKAN_HPP_INLINE void
+      Queue::beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkQueueBeginDebugUtilsLabelEXT &&
+                         "Function <vkQueueBeginDebugUtilsLabelEXT> needs extension <VK_EXT_debug_utils> enabled!" );
+
+      getDispatcher()->vkQueueBeginDebugUtilsLabelEXT( static_cast<VkQueue>( m_queue ),
+                                                       reinterpret_cast<const VkDebugUtilsLabelEXT *>( &labelInfo ) );
+    }
+
+    VULKAN_HPP_INLINE void Queue::endDebugUtilsLabelEXT() const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkQueueEndDebugUtilsLabelEXT &&
+                         "Function <vkQueueEndDebugUtilsLabelEXT> needs extension <VK_EXT_debug_utils> enabled!" );
+
+      getDispatcher()->vkQueueEndDebugUtilsLabelEXT( static_cast<VkQueue>( m_queue ) );
+    }
+
+    VULKAN_HPP_INLINE void
+      Queue::insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkQueueInsertDebugUtilsLabelEXT &&
+                         "Function <vkQueueInsertDebugUtilsLabelEXT> needs extension <VK_EXT_debug_utils> enabled!" );
+
+      getDispatcher()->vkQueueInsertDebugUtilsLabelEXT( static_cast<VkQueue>( m_queue ),
+                                                        reinterpret_cast<const VkDebugUtilsLabelEXT *>( &labelInfo ) );
+    }
+
+    VULKAN_HPP_INLINE void
+      CommandBuffer::beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginDebugUtilsLabelEXT &&
+                         "Function <vkCmdBeginDebugUtilsLabelEXT> needs extension <VK_EXT_debug_utils> enabled!" );
+
+      getDispatcher()->vkCmdBeginDebugUtilsLabelEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                                     reinterpret_cast<const VkDebugUtilsLabelEXT *>( &labelInfo ) );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::endDebugUtilsLabelEXT() const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndDebugUtilsLabelEXT &&
+                         "Function <vkCmdEndDebugUtilsLabelEXT> needs extension <VK_EXT_debug_utils> enabled!" );
+
+      getDispatcher()->vkCmdEndDebugUtilsLabelEXT( static_cast<VkCommandBuffer>( m_commandBuffer ) );
+    }
+
+    VULKAN_HPP_INLINE void
+      CommandBuffer::insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdInsertDebugUtilsLabelEXT &&
+                         "Function <vkCmdInsertDebugUtilsLabelEXT> needs extension <VK_EXT_debug_utils> enabled!" );
+
+      getDispatcher()->vkCmdInsertDebugUtilsLabelEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                                      reinterpret_cast<const VkDebugUtilsLabelEXT *>( &labelInfo ) );
+    }
+
+    VULKAN_HPP_INLINE void Instance::submitDebugUtilsMessageEXT(
+      VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
+      VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT        messageTypes,
+      const DebugUtilsMessengerCallbackDataEXT &                 callbackData ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkSubmitDebugUtilsMessageEXT &&
+                         "Function <vkSubmitDebugUtilsMessageEXT> needs extension <VK_EXT_debug_utils> enabled!" );
+
+      getDispatcher()->vkSubmitDebugUtilsMessageEXT(
+        static_cast<VkInstance>( m_instance ),
+        static_cast<VkDebugUtilsMessageSeverityFlagBitsEXT>( messageSeverity ),
+        static_cast<VkDebugUtilsMessageTypeFlagsEXT>( messageTypes ),
+        reinterpret_cast<const VkDebugUtilsMessengerCallbackDataEXT *>( &callbackData ) );
+    }
+
+#  if defined( VK_USE_PLATFORM_ANDROID_KHR )
+    //=== VK_ANDROID_external_memory_android_hardware_buffer ===
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID
+      Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer ) const
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkGetAndroidHardwareBufferPropertiesANDROID &&
+        "Function <vkGetAndroidHardwareBufferPropertiesANDROID> needs extension <VK_ANDROID_external_memory_android_hardware_buffer> enabled!" );
+
+      VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID properties;
+      VULKAN_HPP_NAMESPACE::Result                                 result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetAndroidHardwareBufferPropertiesANDROID(
           static_cast<VkDevice>( m_device ),
-          bindInfos.size(),
-          reinterpret_cast<const VkBindAccelerationStructureMemoryInfoNV *>( bindInfos.data() ) ) );
+          &buffer,
+          reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID *>( &properties ) ) );
       if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
       {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindAccelerationStructureMemoryNV" );
+        throwResultException( result,
+                              VULKAN_HPP_NAMESPACE_STRING "::Device::getAndroidHardwareBufferPropertiesANDROID" );
       }
+      return properties;
     }
 
-    VULKAN_HPP_INLINE void
-      Device::bindBufferMemory2( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos ) const
+    template <typename X, typename Y, typename... Z>
+    VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
+      Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer ) const
     {
-      VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-        getDispatcher()->vkBindBufferMemory2( static_cast<VkDevice>( m_device ),
-                                              bindInfos.size(),
-                                              reinterpret_cast<const VkBindBufferMemoryInfo *>( bindInfos.data() ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindBufferMemory2" );
-      }
-    }
-
-    VULKAN_HPP_INLINE void Device::bindBufferMemory2KHR(
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos ) const
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkBindBufferMemory2KHR &&
-                         "Function <vkBindBufferMemory2KHR> needs extension <VK_KHR_bind_memory2> enabled!" );
-
+      StructureChain<X, Y, Z...>                                     structureChain;
+      VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID & properties =
+        structureChain.template get<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID>();
       VULKAN_HPP_NAMESPACE::Result result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkBindBufferMemory2KHR(
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetAndroidHardwareBufferPropertiesANDROID(
           static_cast<VkDevice>( m_device ),
-          bindInfos.size(),
-          reinterpret_cast<const VkBindBufferMemoryInfo *>( bindInfos.data() ) ) );
+          &buffer,
+          reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID *>( &properties ) ) );
       if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
       {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindBufferMemory2KHR" );
+        throwResultException( result,
+                              VULKAN_HPP_NAMESPACE_STRING "::Device::getAndroidHardwareBufferPropertiesANDROID" );
       }
+      return structureChain;
     }
 
-    VULKAN_HPP_INLINE void
-      Device::bindImageMemory2( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos ) const
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE struct AHardwareBuffer *
+      Device::getMemoryAndroidHardwareBufferANDROID( const MemoryGetAndroidHardwareBufferInfoANDROID & info ) const
     {
-      VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-        getDispatcher()->vkBindImageMemory2( static_cast<VkDevice>( m_device ),
-                                             bindInfos.size(),
-                                             reinterpret_cast<const VkBindImageMemoryInfo *>( bindInfos.data() ) ) );
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkGetMemoryAndroidHardwareBufferANDROID &&
+        "Function <vkGetMemoryAndroidHardwareBufferANDROID> needs extension <VK_ANDROID_external_memory_android_hardware_buffer> enabled!" );
+
+      struct AHardwareBuffer *     buffer;
+      VULKAN_HPP_NAMESPACE::Result result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetMemoryAndroidHardwareBufferANDROID(
+          static_cast<VkDevice>( m_device ),
+          reinterpret_cast<const VkMemoryGetAndroidHardwareBufferInfoANDROID *>( &info ),
+          &buffer ) );
       if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
       {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindImageMemory2" );
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryAndroidHardwareBufferANDROID" );
       }
+      return buffer;
+    }
+#  endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+
+    //=== VK_EXT_sample_locations ===
+
+    VULKAN_HPP_INLINE void CommandBuffer::setSampleLocationsEXT(
+      const SampleLocationsInfoEXT & sampleLocationsInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetSampleLocationsEXT &&
+                         "Function <vkCmdSetSampleLocationsEXT> needs extension <VK_EXT_sample_locations> enabled!" );
+
+      getDispatcher()->vkCmdSetSampleLocationsEXT(
+        static_cast<VkCommandBuffer>( m_commandBuffer ),
+        reinterpret_cast<const VkSampleLocationsInfoEXT *>( &sampleLocationsInfo ) );
     }
 
-    VULKAN_HPP_INLINE void
-      Device::bindImageMemory2KHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos ) const
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT
+      PhysicalDevice::getMultisamplePropertiesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples ) const
+      VULKAN_HPP_NOEXCEPT
     {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkBindImageMemory2KHR &&
-                         "Function <vkBindImageMemory2KHR> needs extension <VK_KHR_bind_memory2> enabled!" );
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkGetPhysicalDeviceMultisamplePropertiesEXT &&
+        "Function <vkGetPhysicalDeviceMultisamplePropertiesEXT> needs extension <VK_EXT_sample_locations> enabled!" );
 
-      VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-        getDispatcher()->vkBindImageMemory2KHR( static_cast<VkDevice>( m_device ),
-                                                bindInfos.size(),
-                                                reinterpret_cast<const VkBindImageMemoryInfo *>( bindInfos.data() ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT multisampleProperties;
+      getDispatcher()->vkGetPhysicalDeviceMultisamplePropertiesEXT(
+        static_cast<VkPhysicalDevice>( m_physicalDevice ),
+        static_cast<VkSampleCountFlagBits>( samples ),
+        reinterpret_cast<VkMultisamplePropertiesEXT *>( &multisampleProperties ) );
+      return multisampleProperties;
+    }
+
+    //=== VK_KHR_get_memory_requirements2 ===
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2
+      Device::getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkGetImageMemoryRequirements2KHR &&
+        "Function <vkGetImageMemoryRequirements2KHR> needs extension <VK_KHR_get_memory_requirements2> enabled!" );
+
+      VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements;
+      getDispatcher()->vkGetImageMemoryRequirements2KHR(
+        static_cast<VkDevice>( m_device ),
+        reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( &info ),
+        reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
+      return memoryRequirements;
+    }
+
+    template <typename X, typename Y, typename... Z>
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
+      Device::getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkGetImageMemoryRequirements2KHR &&
+        "Function <vkGetImageMemoryRequirements2KHR> needs extension <VK_KHR_get_memory_requirements2> enabled!" );
+
+      StructureChain<X, Y, Z...>                  structureChain;
+      VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements =
+        structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>();
+      getDispatcher()->vkGetImageMemoryRequirements2KHR(
+        static_cast<VkDevice>( m_device ),
+        reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( &info ),
+        reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
+      return structureChain;
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2
+      Device::getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkGetBufferMemoryRequirements2KHR &&
+        "Function <vkGetBufferMemoryRequirements2KHR> needs extension <VK_KHR_get_memory_requirements2> enabled!" );
+
+      VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements;
+      getDispatcher()->vkGetBufferMemoryRequirements2KHR(
+        static_cast<VkDevice>( m_device ),
+        reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( &info ),
+        reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
+      return memoryRequirements;
+    }
+
+    template <typename X, typename Y, typename... Z>
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
+      Device::getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkGetBufferMemoryRequirements2KHR &&
+        "Function <vkGetBufferMemoryRequirements2KHR> needs extension <VK_KHR_get_memory_requirements2> enabled!" );
+
+      StructureChain<X, Y, Z...>                  structureChain;
+      VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements =
+        structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>();
+      getDispatcher()->vkGetBufferMemoryRequirements2KHR(
+        static_cast<VkDevice>( m_device ),
+        reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( &info ),
+        reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
+      return structureChain;
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>
+      Device::getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info ) const
+      VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkGetImageSparseMemoryRequirements2KHR &&
+        "Function <vkGetImageSparseMemoryRequirements2KHR> needs extension <VK_KHR_get_memory_requirements2> enabled!" );
+
+      uint32_t sparseMemoryRequirementCount;
+      getDispatcher()->vkGetImageSparseMemoryRequirements2KHR(
+        static_cast<VkDevice>( m_device ),
+        reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ),
+        &sparseMemoryRequirementCount,
+        nullptr );
+      std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2> sparseMemoryRequirements(
+        sparseMemoryRequirementCount );
+      getDispatcher()->vkGetImageSparseMemoryRequirements2KHR(
+        static_cast<VkDevice>( m_device ),
+        reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ),
+        &sparseMemoryRequirementCount,
+        reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) );
+      VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() );
+      return sparseMemoryRequirements;
+    }
+
+    //=== VK_KHR_acceleration_structure ===
+
+    VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructuresKHR(
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const &      infos,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos )
+      const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkCmdBuildAccelerationStructuresKHR &&
+        "Function <vkCmdBuildAccelerationStructuresKHR> needs extension <VK_KHR_acceleration_structure> enabled!" );
+
+#  ifdef VULKAN_HPP_NO_EXCEPTIONS
+      VULKAN_HPP_ASSERT( infos.size() == pBuildRangeInfos.size() );
+#  else
+      if ( infos.size() != pBuildRangeInfos.size() )
       {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindImageMemory2KHR" );
+        throw LogicError( VULKAN_HPP_NAMESPACE_STRING
+                          "::CommandBuffer::buildAccelerationStructuresKHR: infos.size() != pBuildRangeInfos.size()" );
       }
+#  endif /*VULKAN_HPP_NO_EXCEPTIONS*/
+
+      getDispatcher()->vkCmdBuildAccelerationStructuresKHR(
+        static_cast<VkCommandBuffer>( m_commandBuffer ),
+        infos.size(),
+        reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( infos.data() ),
+        reinterpret_cast<const VkAccelerationStructureBuildRangeInfoKHR * const *>( pBuildRangeInfos.data() ) );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructuresIndirectKHR(
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceAddress> const &                             indirectDeviceAddresses,
+      ArrayProxy<const uint32_t> const &                                                        indirectStrides,
+      ArrayProxy<const uint32_t * const> const & pMaxPrimitiveCounts ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkCmdBuildAccelerationStructuresIndirectKHR &&
+        "Function <vkCmdBuildAccelerationStructuresIndirectKHR> needs extension <VK_KHR_acceleration_structure> enabled!" );
+
+#  ifdef VULKAN_HPP_NO_EXCEPTIONS
+      VULKAN_HPP_ASSERT( infos.size() == indirectDeviceAddresses.size() );
+      VULKAN_HPP_ASSERT( infos.size() == indirectStrides.size() );
+      VULKAN_HPP_ASSERT( infos.size() == pMaxPrimitiveCounts.size() );
+#  else
+      if ( infos.size() != indirectDeviceAddresses.size() )
+      {
+        throw LogicError(
+          VULKAN_HPP_NAMESPACE_STRING
+          "::CommandBuffer::buildAccelerationStructuresIndirectKHR: infos.size() != indirectDeviceAddresses.size()" );
+      }
+      if ( infos.size() != indirectStrides.size() )
+      {
+        throw LogicError(
+          VULKAN_HPP_NAMESPACE_STRING
+          "::CommandBuffer::buildAccelerationStructuresIndirectKHR: infos.size() != indirectStrides.size()" );
+      }
+      if ( infos.size() != pMaxPrimitiveCounts.size() )
+      {
+        throw LogicError(
+          VULKAN_HPP_NAMESPACE_STRING
+          "::CommandBuffer::buildAccelerationStructuresIndirectKHR: infos.size() != pMaxPrimitiveCounts.size()" );
+      }
+#  endif /*VULKAN_HPP_NO_EXCEPTIONS*/
+
+      getDispatcher()->vkCmdBuildAccelerationStructuresIndirectKHR(
+        static_cast<VkCommandBuffer>( m_commandBuffer ),
+        infos.size(),
+        reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( infos.data() ),
+        reinterpret_cast<const VkDeviceAddress *>( indirectDeviceAddresses.data() ),
+        indirectStrides.data(),
+        pMaxPrimitiveCounts.data() );
     }
 
     VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result Device::buildAccelerationStructuresKHR(
@@ -9852,103 +12710,140 @@ namespace VULKAN_HPP_NAMESPACE
       return result;
     }
 
-    VULKAN_HPP_INLINE void Device::debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT & nameInfo ) const
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkDebugMarkerSetObjectNameEXT &&
-                         "Function <vkDebugMarkerSetObjectNameEXT> needs extension <VK_EXT_debug_marker> enabled!" );
-
-      VULKAN_HPP_NAMESPACE::Result result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkDebugMarkerSetObjectNameEXT(
-          static_cast<VkDevice>( m_device ), reinterpret_cast<const VkDebugMarkerObjectNameInfoEXT *>( &nameInfo ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::debugMarkerSetObjectNameEXT" );
-      }
-    }
-
-    VULKAN_HPP_INLINE void Device::debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT & tagInfo ) const
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkDebugMarkerSetObjectTagEXT &&
-                         "Function <vkDebugMarkerSetObjectTagEXT> needs extension <VK_EXT_debug_marker> enabled!" );
-
-      VULKAN_HPP_NAMESPACE::Result result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkDebugMarkerSetObjectTagEXT(
-          static_cast<VkDevice>( m_device ), reinterpret_cast<const VkDebugMarkerObjectTagInfoEXT *>( &tagInfo ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::debugMarkerSetObjectTagEXT" );
-      }
-    }
-
-    VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplateKHR(
-      VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
-      Optional<const AllocationCallbacks>            allocator ) const VULKAN_HPP_NOEXCEPT
+    template <typename T>
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<T> Device::writeAccelerationStructuresPropertiesKHR(
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
+      VULKAN_HPP_NAMESPACE::QueryType                                          queryType,
+      size_t                                                                   dataSize,
+      size_t                                                                   stride ) const
     {
       VULKAN_HPP_ASSERT(
-        getDispatcher()->vkDestroyDescriptorUpdateTemplateKHR &&
-        "Function <vkDestroyDescriptorUpdateTemplateKHR> needs extension <VK_KHR_descriptor_update_template> enabled!" );
+        getDispatcher()->vkWriteAccelerationStructuresPropertiesKHR &&
+        "Function <vkWriteAccelerationStructuresPropertiesKHR> needs extension <VK_KHR_acceleration_structure> enabled!" );
 
-      getDispatcher()->vkDestroyDescriptorUpdateTemplateKHR(
+      VULKAN_HPP_ASSERT( dataSize % sizeof( T ) == 0 );
+      std::vector<T> data( dataSize / sizeof( T ) );
+      Result         result = static_cast<Result>( getDispatcher()->vkWriteAccelerationStructuresPropertiesKHR(
         static_cast<VkDevice>( m_device ),
-        static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
-        reinterpret_cast<const VkAllocationCallbacks *>(
-          static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+        accelerationStructures.size(),
+        reinterpret_cast<const VkAccelerationStructureKHR *>( accelerationStructures.data() ),
+        static_cast<VkQueryType>( queryType ),
+        data.size() * sizeof( T ),
+        reinterpret_cast<void *>( data.data() ),
+        stride ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result,
+                              VULKAN_HPP_NAMESPACE_STRING "::Device::writeAccelerationStructuresPropertiesKHR" );
+      }
+      return data;
     }
 
-    VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversionKHR(
-      VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion,
-      Optional<const AllocationCallbacks>          allocator ) const VULKAN_HPP_NOEXCEPT
+    template <typename T>
+    VULKAN_HPP_NODISCARD T Device::writeAccelerationStructuresPropertyKHR(
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
+      VULKAN_HPP_NAMESPACE::QueryType                                          queryType,
+      size_t                                                                   stride ) const
+    {
+      T      data;
+      Result result = static_cast<Result>( getDispatcher()->vkWriteAccelerationStructuresPropertiesKHR(
+        static_cast<VkDevice>( m_device ),
+        accelerationStructures.size(),
+        reinterpret_cast<const VkAccelerationStructureKHR *>( accelerationStructures.data() ),
+        static_cast<VkQueryType>( queryType ),
+        sizeof( T ),
+        reinterpret_cast<void *>( &data ),
+        stride ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::writeAccelerationStructuresPropertyKHR" );
+      }
+      return data;
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureKHR(
+      const CopyAccelerationStructureInfoKHR & info ) const VULKAN_HPP_NOEXCEPT
     {
       VULKAN_HPP_ASSERT(
-        getDispatcher()->vkDestroySamplerYcbcrConversionKHR &&
-        "Function <vkDestroySamplerYcbcrConversionKHR> needs extension <VK_KHR_sampler_ycbcr_conversion> enabled!" );
+        getDispatcher()->vkCmdCopyAccelerationStructureKHR &&
+        "Function <vkCmdCopyAccelerationStructureKHR> needs extension <VK_KHR_acceleration_structure> enabled!" );
 
-      getDispatcher()->vkDestroySamplerYcbcrConversionKHR(
+      getDispatcher()->vkCmdCopyAccelerationStructureKHR(
+        static_cast<VkCommandBuffer>( m_commandBuffer ),
+        reinterpret_cast<const VkCopyAccelerationStructureInfoKHR *>( &info ) );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureToMemoryKHR(
+      const CopyAccelerationStructureToMemoryInfoKHR & info ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkCmdCopyAccelerationStructureToMemoryKHR &&
+        "Function <vkCmdCopyAccelerationStructureToMemoryKHR> needs extension <VK_KHR_acceleration_structure> enabled!" );
+
+      getDispatcher()->vkCmdCopyAccelerationStructureToMemoryKHR(
+        static_cast<VkCommandBuffer>( m_commandBuffer ),
+        reinterpret_cast<const VkCopyAccelerationStructureToMemoryInfoKHR *>( &info ) );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::copyMemoryToAccelerationStructureKHR(
+      const CopyMemoryToAccelerationStructureInfoKHR & info ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkCmdCopyMemoryToAccelerationStructureKHR &&
+        "Function <vkCmdCopyMemoryToAccelerationStructureKHR> needs extension <VK_KHR_acceleration_structure> enabled!" );
+
+      getDispatcher()->vkCmdCopyMemoryToAccelerationStructureKHR(
+        static_cast<VkCommandBuffer>( m_commandBuffer ),
+        reinterpret_cast<const VkCopyMemoryToAccelerationStructureInfoKHR *>( &info ) );
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceAddress
+      Device::getAccelerationStructureAddressKHR( const AccelerationStructureDeviceAddressInfoKHR & info ) const
+      VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkGetAccelerationStructureDeviceAddressKHR &&
+        "Function <vkGetAccelerationStructureDeviceAddressKHR> needs extension <VK_KHR_acceleration_structure> enabled!" );
+
+      return static_cast<VULKAN_HPP_NAMESPACE::DeviceAddress>(
+        getDispatcher()->vkGetAccelerationStructureDeviceAddressKHR(
+          static_cast<VkDevice>( m_device ),
+          reinterpret_cast<const VkAccelerationStructureDeviceAddressInfoKHR *>( &info ) ) );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesKHR(
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
+      VULKAN_HPP_NAMESPACE::QueryType                                          queryType,
+      VULKAN_HPP_NAMESPACE::QueryPool                                          queryPool,
+      uint32_t                                                                 firstQuery ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkCmdWriteAccelerationStructuresPropertiesKHR &&
+        "Function <vkCmdWriteAccelerationStructuresPropertiesKHR> needs extension <VK_KHR_acceleration_structure> enabled!" );
+
+      getDispatcher()->vkCmdWriteAccelerationStructuresPropertiesKHR(
+        static_cast<VkCommandBuffer>( m_commandBuffer ),
+        accelerationStructures.size(),
+        reinterpret_cast<const VkAccelerationStructureKHR *>( accelerationStructures.data() ),
+        static_cast<VkQueryType>( queryType ),
+        static_cast<VkQueryPool>( queryPool ),
+        firstQuery );
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR
+      Device::getAccelerationStructureCompatibilityKHR( const AccelerationStructureVersionInfoKHR & versionInfo ) const
+      VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkGetDeviceAccelerationStructureCompatibilityKHR &&
+        "Function <vkGetDeviceAccelerationStructureCompatibilityKHR> needs extension <VK_KHR_acceleration_structure> enabled!" );
+
+      VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR compatibility;
+      getDispatcher()->vkGetDeviceAccelerationStructureCompatibilityKHR(
         static_cast<VkDevice>( m_device ),
-        static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ),
-        reinterpret_cast<const VkAllocationCallbacks *>(
-          static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
-    }
-
-    VULKAN_HPP_INLINE void Device::waitIdle() const
-    {
-      VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-        getDispatcher()->vkDeviceWaitIdle( static_cast<VkDevice>( m_device ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::waitIdle" );
-      }
-    }
-
-    VULKAN_HPP_INLINE void Device::displayPowerControlEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display,
-                                                           const DisplayPowerInfoEXT &      displayPowerInfo ) const
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkDisplayPowerControlEXT &&
-                         "Function <vkDisplayPowerControlEXT> needs extension <VK_EXT_display_control> enabled!" );
-
-      VULKAN_HPP_NAMESPACE::Result result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkDisplayPowerControlEXT(
-          static_cast<VkDevice>( m_device ),
-          static_cast<VkDisplayKHR>( display ),
-          reinterpret_cast<const VkDisplayPowerInfoEXT *>( &displayPowerInfo ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::displayPowerControlEXT" );
-      }
-    }
-
-    VULKAN_HPP_INLINE void Device::flushMappedMemoryRanges(
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges ) const
-    {
-      VULKAN_HPP_NAMESPACE::Result result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkFlushMappedMemoryRanges(
-          static_cast<VkDevice>( m_device ),
-          memoryRanges.size(),
-          reinterpret_cast<const VkMappedMemoryRange *>( memoryRanges.data() ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::flushMappedMemoryRanges" );
-      }
+        reinterpret_cast<const VkAccelerationStructureVersionInfoKHR *>( &versionInfo ),
+        reinterpret_cast<VkAccelerationStructureCompatibilityKHR *>( &compatibility ) );
+      return compatibility;
     }
 
     VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR
@@ -9971,20 +12866,183 @@ namespace VULKAN_HPP_NAMESPACE
       return sizeInfo;
     }
 
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceAddress
-      Device::getAccelerationStructureAddressKHR( const AccelerationStructureDeviceAddressInfoKHR & info ) const
-      VULKAN_HPP_NOEXCEPT
+    //=== VK_KHR_sampler_ycbcr_conversion ===
+
+    VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversionKHR(
+      VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion,
+      Optional<const AllocationCallbacks>          allocator ) const VULKAN_HPP_NOEXCEPT
     {
       VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetAccelerationStructureDeviceAddressKHR &&
-        "Function <vkGetAccelerationStructureDeviceAddressKHR> needs extension <VK_KHR_acceleration_structure> enabled!" );
+        getDispatcher()->vkDestroySamplerYcbcrConversionKHR &&
+        "Function <vkDestroySamplerYcbcrConversionKHR> needs extension <VK_KHR_sampler_ycbcr_conversion> enabled!" );
 
-      return static_cast<VULKAN_HPP_NAMESPACE::DeviceAddress>(
-        getDispatcher()->vkGetAccelerationStructureDeviceAddressKHR(
-          static_cast<VkDevice>( m_device ),
-          reinterpret_cast<const VkAccelerationStructureDeviceAddressInfoKHR *>( &info ) ) );
+      getDispatcher()->vkDestroySamplerYcbcrConversionKHR(
+        static_cast<VkDevice>( m_device ),
+        static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ),
+        reinterpret_cast<const VkAllocationCallbacks *>(
+          static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
     }
 
+    //=== VK_KHR_bind_memory2 ===
+
+    VULKAN_HPP_INLINE void Device::bindBufferMemory2KHR(
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos ) const
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkBindBufferMemory2KHR &&
+                         "Function <vkBindBufferMemory2KHR> needs extension <VK_KHR_bind_memory2> enabled!" );
+
+      VULKAN_HPP_NAMESPACE::Result result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkBindBufferMemory2KHR(
+          static_cast<VkDevice>( m_device ),
+          bindInfos.size(),
+          reinterpret_cast<const VkBindBufferMemoryInfo *>( bindInfos.data() ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindBufferMemory2KHR" );
+      }
+    }
+
+    VULKAN_HPP_INLINE void
+      Device::bindImageMemory2KHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos ) const
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkBindImageMemory2KHR &&
+                         "Function <vkBindImageMemory2KHR> needs extension <VK_KHR_bind_memory2> enabled!" );
+
+      VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
+        getDispatcher()->vkBindImageMemory2KHR( static_cast<VkDevice>( m_device ),
+                                                bindInfos.size(),
+                                                reinterpret_cast<const VkBindImageMemoryInfo *>( bindInfos.data() ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindImageMemory2KHR" );
+      }
+    }
+
+    //=== VK_EXT_image_drm_format_modifier ===
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT
+                                           Image::getDrmFormatModifierPropertiesEXT() const
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkGetImageDrmFormatModifierPropertiesEXT &&
+        "Function <vkGetImageDrmFormatModifierPropertiesEXT> needs extension <VK_EXT_image_drm_format_modifier> enabled!" );
+
+      VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT properties;
+      VULKAN_HPP_NAMESPACE::Result                              result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetImageDrmFormatModifierPropertiesEXT(
+          static_cast<VkDevice>( m_device ),
+          static_cast<VkImage>( m_image ),
+          reinterpret_cast<VkImageDrmFormatModifierPropertiesEXT *>( &properties ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Image::getDrmFormatModifierPropertiesEXT" );
+      }
+      return properties;
+    }
+
+    //=== VK_EXT_validation_cache ===
+
+    VULKAN_HPP_INLINE void
+      ValidationCacheEXT::merge( ArrayProxy<const VULKAN_HPP_NAMESPACE::ValidationCacheEXT> const & srcCaches ) const
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkMergeValidationCachesEXT &&
+                         "Function <vkMergeValidationCachesEXT> needs extension <VK_EXT_validation_cache> enabled!" );
+
+      VULKAN_HPP_NAMESPACE::Result result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkMergeValidationCachesEXT(
+          static_cast<VkDevice>( m_device ),
+          static_cast<VkValidationCacheEXT>( m_validationCacheEXT ),
+          srcCaches.size(),
+          reinterpret_cast<const VkValidationCacheEXT *>( srcCaches.data() ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::ValidationCacheEXT::merge" );
+      }
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<uint8_t> ValidationCacheEXT::getData() const
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkGetValidationCacheDataEXT &&
+                         "Function <vkGetValidationCacheDataEXT> needs extension <VK_EXT_validation_cache> enabled!" );
+
+      std::vector<uint8_t>         data;
+      size_t                       dataSize;
+      VULKAN_HPP_NAMESPACE::Result result;
+      do
+      {
+        result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
+          getDispatcher()->vkGetValidationCacheDataEXT( static_cast<VkDevice>( m_device ),
+                                                        static_cast<VkValidationCacheEXT>( m_validationCacheEXT ),
+                                                        &dataSize,
+                                                        nullptr ) );
+        if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && dataSize )
+        {
+          data.resize( dataSize );
+          result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
+            getDispatcher()->vkGetValidationCacheDataEXT( static_cast<VkDevice>( m_device ),
+                                                          static_cast<VkValidationCacheEXT>( m_validationCacheEXT ),
+                                                          &dataSize,
+                                                          reinterpret_cast<void *>( data.data() ) ) );
+          VULKAN_HPP_ASSERT( dataSize <= data.size() );
+        }
+      } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
+      if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( dataSize < data.size() ) )
+      {
+        data.resize( dataSize );
+      }
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::ValidationCacheEXT::getData" );
+      }
+      return data;
+    }
+
+    //=== VK_NV_shading_rate_image ===
+
+    VULKAN_HPP_INLINE void
+      CommandBuffer::bindShadingRateImageNV( VULKAN_HPP_NAMESPACE::ImageView   imageView,
+                                             VULKAN_HPP_NAMESPACE::ImageLayout imageLayout ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindShadingRateImageNV &&
+                         "Function <vkCmdBindShadingRateImageNV> needs extension <VK_NV_shading_rate_image> enabled!" );
+
+      getDispatcher()->vkCmdBindShadingRateImageNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                                    static_cast<VkImageView>( imageView ),
+                                                    static_cast<VkImageLayout>( imageLayout ) );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::setViewportShadingRatePaletteNV(
+      uint32_t firstViewport, ArrayProxy<const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV> const & shadingRatePalettes )
+      const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkCmdSetViewportShadingRatePaletteNV &&
+        "Function <vkCmdSetViewportShadingRatePaletteNV> needs extension <VK_NV_shading_rate_image> enabled!" );
+
+      getDispatcher()->vkCmdSetViewportShadingRatePaletteNV(
+        static_cast<VkCommandBuffer>( m_commandBuffer ),
+        firstViewport,
+        shadingRatePalettes.size(),
+        reinterpret_cast<const VkShadingRatePaletteNV *>( shadingRatePalettes.data() ) );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::setCoarseSampleOrderNV(
+      VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV                             sampleOrderType,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV> const & customSampleOrders ) const
+      VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetCoarseSampleOrderNV &&
+                         "Function <vkCmdSetCoarseSampleOrderNV> needs extension <VK_NV_shading_rate_image> enabled!" );
+
+      getDispatcher()->vkCmdSetCoarseSampleOrderNV(
+        static_cast<VkCommandBuffer>( m_commandBuffer ),
+        static_cast<VkCoarseSampleOrderTypeNV>( sampleOrderType ),
+        customSampleOrders.size(),
+        reinterpret_cast<const VkCoarseSampleOrderCustomNV *>( customSampleOrders.data() ) );
+    }
+
+    //=== VK_NV_ray_tracing ===
+
     VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR
                                            Device::getAccelerationStructureMemoryRequirementsNV(
         const AccelerationStructureMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT
@@ -10020,208 +13078,211 @@ namespace VULKAN_HPP_NAMESPACE
       return structureChain;
     }
 
-#  if defined( VK_USE_PLATFORM_ANDROID_KHR )
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID
-      Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer ) const
+    VULKAN_HPP_INLINE void Device::bindAccelerationStructureMemoryNV(
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV> const & bindInfos ) const
     {
       VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetAndroidHardwareBufferPropertiesANDROID &&
-        "Function <vkGetAndroidHardwareBufferPropertiesANDROID> needs extension <VK_ANDROID_external_memory_android_hardware_buffer> enabled!" );
+        getDispatcher()->vkBindAccelerationStructureMemoryNV &&
+        "Function <vkBindAccelerationStructureMemoryNV> needs extension <VK_NV_ray_tracing> enabled!" );
 
-      VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID properties;
-      VULKAN_HPP_NAMESPACE::Result                                 result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetAndroidHardwareBufferPropertiesANDROID(
-          static_cast<VkDevice>( m_device ),
-          &buffer,
-          reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID *>( &properties ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result,
-                              VULKAN_HPP_NAMESPACE_STRING "::Device::getAndroidHardwareBufferPropertiesANDROID" );
-      }
-      return properties;
-    }
-#  endif /*VK_USE_PLATFORM_ANDROID_KHR*/
-
-#  if defined( VK_USE_PLATFORM_ANDROID_KHR )
-    template <typename X, typename Y, typename... Z>
-    VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
-      Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer ) const
-    {
-      StructureChain<X, Y, Z...>                                     structureChain;
-      VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID & properties =
-        structureChain.template get<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID>();
       VULKAN_HPP_NAMESPACE::Result result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetAndroidHardwareBufferPropertiesANDROID(
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkBindAccelerationStructureMemoryNV(
           static_cast<VkDevice>( m_device ),
-          &buffer,
-          reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID *>( &properties ) ) );
+          bindInfos.size(),
+          reinterpret_cast<const VkBindAccelerationStructureMemoryInfoNV *>( bindInfos.data() ) ) );
       if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
       {
-        throwResultException( result,
-                              VULKAN_HPP_NAMESPACE_STRING "::Device::getAndroidHardwareBufferPropertiesANDROID" );
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindAccelerationStructureMemoryNV" );
       }
-      return structureChain;
     }
-#  endif /*VK_USE_PLATFORM_ANDROID_KHR*/
 
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceAddress
-      Device::getBufferAddress( const BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT
+    VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructureNV(
+      const AccelerationStructureInfoNV &           info,
+      VULKAN_HPP_NAMESPACE::Buffer                  instanceData,
+      VULKAN_HPP_NAMESPACE::DeviceSize              instanceOffset,
+      VULKAN_HPP_NAMESPACE::Bool32                  update,
+      VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst,
+      VULKAN_HPP_NAMESPACE::AccelerationStructureNV src,
+      VULKAN_HPP_NAMESPACE::Buffer                  scratch,
+      VULKAN_HPP_NAMESPACE::DeviceSize              scratchOffset ) const VULKAN_HPP_NOEXCEPT
     {
-      return static_cast<VULKAN_HPP_NAMESPACE::DeviceAddress>( getDispatcher()->vkGetBufferDeviceAddress(
-        static_cast<VkDevice>( m_device ), reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) ) );
+      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBuildAccelerationStructureNV &&
+                         "Function <vkCmdBuildAccelerationStructureNV> needs extension <VK_NV_ray_tracing> enabled!" );
+
+      getDispatcher()->vkCmdBuildAccelerationStructureNV(
+        static_cast<VkCommandBuffer>( m_commandBuffer ),
+        reinterpret_cast<const VkAccelerationStructureInfoNV *>( &info ),
+        static_cast<VkBuffer>( instanceData ),
+        static_cast<VkDeviceSize>( instanceOffset ),
+        static_cast<VkBool32>( update ),
+        static_cast<VkAccelerationStructureNV>( dst ),
+        static_cast<VkAccelerationStructureNV>( src ),
+        static_cast<VkBuffer>( scratch ),
+        static_cast<VkDeviceSize>( scratchOffset ) );
     }
 
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceAddress
-      Device::getBufferAddressEXT( const BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT
+    VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureNV(
+      VULKAN_HPP_NAMESPACE::AccelerationStructureNV          dst,
+      VULKAN_HPP_NAMESPACE::AccelerationStructureNV          src,
+      VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR mode ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyAccelerationStructureNV &&
+                         "Function <vkCmdCopyAccelerationStructureNV> needs extension <VK_NV_ray_tracing> enabled!" );
+
+      getDispatcher()->vkCmdCopyAccelerationStructureNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                                         static_cast<VkAccelerationStructureNV>( dst ),
+                                                         static_cast<VkAccelerationStructureNV>( src ),
+                                                         static_cast<VkCopyAccelerationStructureModeKHR>( mode ) );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::traceRaysNV( VULKAN_HPP_NAMESPACE::Buffer     raygenShaderBindingTableBuffer,
+                                                       VULKAN_HPP_NAMESPACE::DeviceSize raygenShaderBindingOffset,
+                                                       VULKAN_HPP_NAMESPACE::Buffer     missShaderBindingTableBuffer,
+                                                       VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingOffset,
+                                                       VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingStride,
+                                                       VULKAN_HPP_NAMESPACE::Buffer     hitShaderBindingTableBuffer,
+                                                       VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingOffset,
+                                                       VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingStride,
+                                                       VULKAN_HPP_NAMESPACE::Buffer callableShaderBindingTableBuffer,
+                                                       VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingOffset,
+                                                       VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingStride,
+                                                       uint32_t                         width,
+                                                       uint32_t                         height,
+                                                       uint32_t depth ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdTraceRaysNV &&
+                         "Function <vkCmdTraceRaysNV> needs extension <VK_NV_ray_tracing> enabled!" );
+
+      getDispatcher()->vkCmdTraceRaysNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                         static_cast<VkBuffer>( raygenShaderBindingTableBuffer ),
+                                         static_cast<VkDeviceSize>( raygenShaderBindingOffset ),
+                                         static_cast<VkBuffer>( missShaderBindingTableBuffer ),
+                                         static_cast<VkDeviceSize>( missShaderBindingOffset ),
+                                         static_cast<VkDeviceSize>( missShaderBindingStride ),
+                                         static_cast<VkBuffer>( hitShaderBindingTableBuffer ),
+                                         static_cast<VkDeviceSize>( hitShaderBindingOffset ),
+                                         static_cast<VkDeviceSize>( hitShaderBindingStride ),
+                                         static_cast<VkBuffer>( callableShaderBindingTableBuffer ),
+                                         static_cast<VkDeviceSize>( callableShaderBindingOffset ),
+                                         static_cast<VkDeviceSize>( callableShaderBindingStride ),
+                                         width,
+                                         height,
+                                         depth );
+    }
+
+    template <typename T>
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<T>
+      Pipeline::getRayTracingShaderGroupHandlesNV( uint32_t firstGroup, uint32_t groupCount, size_t dataSize ) const
     {
       VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetBufferDeviceAddressEXT &&
-        "Function <vkGetBufferDeviceAddressEXT> needs extension <VK_EXT_buffer_device_address> enabled!" );
+        getDispatcher()->vkGetRayTracingShaderGroupHandlesNV &&
+        "Function <vkGetRayTracingShaderGroupHandlesNV> needs extension <VK_NV_ray_tracing> enabled!" );
 
-      return static_cast<VULKAN_HPP_NAMESPACE::DeviceAddress>( getDispatcher()->vkGetBufferDeviceAddressEXT(
-        static_cast<VkDevice>( m_device ), reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) ) );
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceAddress
-      Device::getBufferAddressKHR( const BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetBufferDeviceAddressKHR &&
-        "Function <vkGetBufferDeviceAddressKHR> needs extension <VK_KHR_buffer_device_address> enabled!" );
-
-      return static_cast<VULKAN_HPP_NAMESPACE::DeviceAddress>( getDispatcher()->vkGetBufferDeviceAddressKHR(
-        static_cast<VkDevice>( m_device ), reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) ) );
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2
-      Device::getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements;
-      getDispatcher()->vkGetBufferMemoryRequirements2(
-        static_cast<VkDevice>( m_device ),
-        reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( &info ),
-        reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
-      return memoryRequirements;
-    }
-
-    template <typename X, typename Y, typename... Z>
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
-      Device::getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT
-    {
-      StructureChain<X, Y, Z...>                  structureChain;
-      VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements =
-        structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>();
-      getDispatcher()->vkGetBufferMemoryRequirements2(
-        static_cast<VkDevice>( m_device ),
-        reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( &info ),
-        reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
-      return structureChain;
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2
-      Device::getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetBufferMemoryRequirements2KHR &&
-        "Function <vkGetBufferMemoryRequirements2KHR> needs extension <VK_KHR_get_memory_requirements2> enabled!" );
-
-      VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements;
-      getDispatcher()->vkGetBufferMemoryRequirements2KHR(
-        static_cast<VkDevice>( m_device ),
-        reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( &info ),
-        reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
-      return memoryRequirements;
-    }
-
-    template <typename X, typename Y, typename... Z>
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
-      Device::getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetBufferMemoryRequirements2KHR &&
-        "Function <vkGetBufferMemoryRequirements2KHR> needs extension <VK_KHR_get_memory_requirements2> enabled!" );
-
-      StructureChain<X, Y, Z...>                  structureChain;
-      VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements =
-        structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>();
-      getDispatcher()->vkGetBufferMemoryRequirements2KHR(
-        static_cast<VkDevice>( m_device ),
-        reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( &info ),
-        reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
-      return structureChain;
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t
-      Device::getBufferOpaqueCaptureAddress( const BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT
-    {
-      return getDispatcher()->vkGetBufferOpaqueCaptureAddress(
-        static_cast<VkDevice>( m_device ), reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) );
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t
-      Device::getBufferOpaqueCaptureAddressKHR( const BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetBufferOpaqueCaptureAddressKHR &&
-        "Function <vkGetBufferOpaqueCaptureAddressKHR> needs extension <VK_KHR_buffer_device_address> enabled!" );
-
-      return getDispatcher()->vkGetBufferOpaqueCaptureAddressKHR(
-        static_cast<VkDevice>( m_device ), reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) );
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<std::vector<uint64_t>, uint64_t>
-                                           Device::getCalibratedTimestampsEXT(
-        ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT> const & timestampInfos ) const
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetCalibratedTimestampsEXT &&
-        "Function <vkGetCalibratedTimestampsEXT> needs extension <VK_EXT_calibrated_timestamps> enabled!" );
-
-      std::pair<std::vector<uint64_t>, uint64_t> data(
-        std::piecewise_construct, std::forward_as_tuple( timestampInfos.size() ), std::forward_as_tuple( 0 ) );
-      std::vector<uint64_t> &      timestamps   = data.first;
-      uint64_t &                   maxDeviation = data.second;
-      VULKAN_HPP_NAMESPACE::Result result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetCalibratedTimestampsEXT(
-          static_cast<VkDevice>( m_device ),
-          timestampInfos.size(),
-          reinterpret_cast<const VkCalibratedTimestampInfoEXT *>( timestampInfos.data() ),
-          timestamps.data(),
-          &maxDeviation ) );
+      VULKAN_HPP_ASSERT( dataSize % sizeof( T ) == 0 );
+      std::vector<T> data( dataSize / sizeof( T ) );
+      Result         result = static_cast<Result>(
+        getDispatcher()->vkGetRayTracingShaderGroupHandlesNV( static_cast<VkDevice>( m_device ),
+                                                              static_cast<VkPipeline>( m_pipeline ),
+                                                              firstGroup,
+                                                              groupCount,
+                                                              data.size() * sizeof( T ),
+                                                              reinterpret_cast<void *>( data.data() ) ) );
       if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
       {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsEXT" );
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Pipeline::getRayTracingShaderGroupHandlesNV" );
       }
       return data;
     }
 
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport
-      Device::getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo ) const
-      VULKAN_HPP_NOEXCEPT
+    template <typename T>
+    VULKAN_HPP_NODISCARD T Pipeline::getRayTracingShaderGroupHandleNV( uint32_t firstGroup, uint32_t groupCount ) const
     {
-      VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport support;
-      getDispatcher()->vkGetDescriptorSetLayoutSupport(
-        static_cast<VkDevice>( m_device ),
-        reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ),
-        reinterpret_cast<VkDescriptorSetLayoutSupport *>( &support ) );
-      return support;
+      T      data;
+      Result result = static_cast<Result>(
+        getDispatcher()->vkGetRayTracingShaderGroupHandlesNV( static_cast<VkDevice>( m_device ),
+                                                              static_cast<VkPipeline>( m_pipeline ),
+                                                              firstGroup,
+                                                              groupCount,
+                                                              sizeof( T ),
+                                                              reinterpret_cast<void *>( &data ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Pipeline::getRayTracingShaderGroupHandleNV" );
+      }
+      return data;
     }
 
-    template <typename X, typename Y, typename... Z>
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getDescriptorSetLayoutSupport(
-      const DescriptorSetLayoutCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT
+    template <typename T>
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<T> AccelerationStructureNV::getHandle( size_t dataSize ) const
     {
-      StructureChain<X, Y, Z...>                         structureChain;
-      VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport & support =
-        structureChain.template get<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport>();
-      getDispatcher()->vkGetDescriptorSetLayoutSupport(
+      VULKAN_HPP_ASSERT( getDispatcher()->vkGetAccelerationStructureHandleNV &&
+                         "Function <vkGetAccelerationStructureHandleNV> needs extension <VK_NV_ray_tracing> enabled!" );
+
+      VULKAN_HPP_ASSERT( dataSize % sizeof( T ) == 0 );
+      std::vector<T> data( dataSize / sizeof( T ) );
+      Result         result = static_cast<Result>( getDispatcher()->vkGetAccelerationStructureHandleNV(
         static_cast<VkDevice>( m_device ),
-        reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ),
-        reinterpret_cast<VkDescriptorSetLayoutSupport *>( &support ) );
-      return structureChain;
+        static_cast<VkAccelerationStructureNV>( m_accelerationStructureNV ),
+        data.size() * sizeof( T ),
+        reinterpret_cast<void *>( data.data() ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::AccelerationStructureNV::getHandle" );
+      }
+      return data;
     }
 
+    template <typename T>
+    VULKAN_HPP_NODISCARD T AccelerationStructureNV::getHandle() const
+    {
+      T      data;
+      Result result = static_cast<Result>( getDispatcher()->vkGetAccelerationStructureHandleNV(
+        static_cast<VkDevice>( m_device ),
+        static_cast<VkAccelerationStructureNV>( m_accelerationStructureNV ),
+        sizeof( T ),
+        reinterpret_cast<void *>( &data ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::AccelerationStructureNV::getHandle" );
+      }
+      return data;
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesNV(
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureNV> const & accelerationStructures,
+      VULKAN_HPP_NAMESPACE::QueryType                                         queryType,
+      VULKAN_HPP_NAMESPACE::QueryPool                                         queryPool,
+      uint32_t                                                                firstQuery ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkCmdWriteAccelerationStructuresPropertiesNV &&
+        "Function <vkCmdWriteAccelerationStructuresPropertiesNV> needs extension <VK_NV_ray_tracing> enabled!" );
+
+      getDispatcher()->vkCmdWriteAccelerationStructuresPropertiesNV(
+        static_cast<VkCommandBuffer>( m_commandBuffer ),
+        accelerationStructures.size(),
+        reinterpret_cast<const VkAccelerationStructureNV *>( accelerationStructures.data() ),
+        static_cast<VkQueryType>( queryType ),
+        static_cast<VkQueryPool>( queryPool ),
+        firstQuery );
+    }
+
+    VULKAN_HPP_INLINE void Pipeline::compileDeferredNV( uint32_t shader ) const
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkCompileDeferredNV &&
+                         "Function <vkCompileDeferredNV> needs extension <VK_NV_ray_tracing> enabled!" );
+
+      VULKAN_HPP_NAMESPACE::Result result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCompileDeferredNV(
+          static_cast<VkDevice>( m_device ), static_cast<VkPipeline>( m_pipeline ), shader ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Pipeline::compileDeferredNV" );
+      }
+    }
+
+    //=== VK_KHR_maintenance3 ===
+
     VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport
       Device::getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo ) const
       VULKAN_HPP_NOEXCEPT
@@ -10256,383 +13317,49 @@ namespace VULKAN_HPP_NAMESPACE
       return structureChain;
     }
 
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR
-      Device::getAccelerationStructureCompatibilityKHR( const AccelerationStructureVersionInfoKHR & versionInfo ) const
-      VULKAN_HPP_NOEXCEPT
+    //=== VK_KHR_draw_indirect_count ===
+
+    VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer     buffer,
+                                                                VULKAN_HPP_NAMESPACE::DeviceSize offset,
+                                                                VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
+                                                                VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
+                                                                uint32_t                         maxDrawCount,
+                                                                uint32_t stride ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawIndirectCountKHR &&
+                         "Function <vkCmdDrawIndirectCountKHR> needs extension <VK_KHR_draw_indirect_count> enabled!" );
+
+      getDispatcher()->vkCmdDrawIndirectCountKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                                  static_cast<VkBuffer>( buffer ),
+                                                  static_cast<VkDeviceSize>( offset ),
+                                                  static_cast<VkBuffer>( countBuffer ),
+                                                  static_cast<VkDeviceSize>( countBufferOffset ),
+                                                  maxDrawCount,
+                                                  stride );
+    }
+
+    VULKAN_HPP_INLINE void
+      CommandBuffer::drawIndexedIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer     buffer,
+                                                  VULKAN_HPP_NAMESPACE::DeviceSize offset,
+                                                  VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
+                                                  VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
+                                                  uint32_t                         maxDrawCount,
+                                                  uint32_t                         stride ) const VULKAN_HPP_NOEXCEPT
     {
       VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetDeviceAccelerationStructureCompatibilityKHR &&
-        "Function <vkGetDeviceAccelerationStructureCompatibilityKHR> needs extension <VK_KHR_acceleration_structure> enabled!" );
+        getDispatcher()->vkCmdDrawIndexedIndirectCountKHR &&
+        "Function <vkCmdDrawIndexedIndirectCountKHR> needs extension <VK_KHR_draw_indirect_count> enabled!" );
 
-      VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR compatibility;
-      getDispatcher()->vkGetDeviceAccelerationStructureCompatibilityKHR(
-        static_cast<VkDevice>( m_device ),
-        reinterpret_cast<const VkAccelerationStructureVersionInfoKHR *>( &versionInfo ),
-        reinterpret_cast<VkAccelerationStructureCompatibilityKHR *>( &compatibility ) );
-      return compatibility;
+      getDispatcher()->vkCmdDrawIndexedIndirectCountKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                                         static_cast<VkBuffer>( buffer ),
+                                                         static_cast<VkDeviceSize>( offset ),
+                                                         static_cast<VkBuffer>( countBuffer ),
+                                                         static_cast<VkDeviceSize>( countBufferOffset ),
+                                                         maxDrawCount,
+                                                         stride );
     }
 
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags
-                                           Device::getGroupPeerMemoryFeatures( uint32_t heapIndex,
-                                          uint32_t localDeviceIndex,
-                                          uint32_t remoteDeviceIndex ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags peerMemoryFeatures;
-      getDispatcher()->vkGetDeviceGroupPeerMemoryFeatures(
-        static_cast<VkDevice>( m_device ),
-        heapIndex,
-        localDeviceIndex,
-        remoteDeviceIndex,
-        reinterpret_cast<VkPeerMemoryFeatureFlags *>( &peerMemoryFeatures ) );
-      return peerMemoryFeatures;
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags
-                                           Device::getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex,
-                                             uint32_t localDeviceIndex,
-                                             uint32_t remoteDeviceIndex ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetDeviceGroupPeerMemoryFeaturesKHR &&
-        "Function <vkGetDeviceGroupPeerMemoryFeaturesKHR> needs extension <VK_KHR_device_group> enabled!" );
-
-      VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags peerMemoryFeatures;
-      getDispatcher()->vkGetDeviceGroupPeerMemoryFeaturesKHR(
-        static_cast<VkDevice>( m_device ),
-        heapIndex,
-        localDeviceIndex,
-        remoteDeviceIndex,
-        reinterpret_cast<VkPeerMemoryFeatureFlags *>( &peerMemoryFeatures ) );
-      return peerMemoryFeatures;
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR
-                                           Device::getGroupPresentCapabilitiesKHR() const
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetDeviceGroupPresentCapabilitiesKHR &&
-        "Function <vkGetDeviceGroupPresentCapabilitiesKHR> needs extension <VK_KHR_swapchain> enabled!" );
-
-      VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR deviceGroupPresentCapabilities;
-      VULKAN_HPP_NAMESPACE::Result                            result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetDeviceGroupPresentCapabilitiesKHR(
-          static_cast<VkDevice>( m_device ),
-          reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR *>( &deviceGroupPresentCapabilities ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupPresentCapabilitiesKHR" );
-      }
-      return deviceGroupPresentCapabilities;
-    }
-
-#  if defined( VK_USE_PLATFORM_WIN32_KHR )
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR
-      Device::getGroupSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetDeviceGroupSurfacePresentModes2EXT &&
-        "Function <vkGetDeviceGroupSurfacePresentModes2EXT> needs extension <VK_EXT_full_screen_exclusive> enabled!" );
-
-      VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR modes;
-      VULKAN_HPP_NAMESPACE::Result                         result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetDeviceGroupSurfacePresentModes2EXT(
-          static_cast<VkDevice>( m_device ),
-          reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
-          reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR *>( &modes ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupSurfacePresentModes2EXT" );
-      }
-      return modes;
-    }
-#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR
-      Device::getGroupSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetDeviceGroupSurfacePresentModesKHR &&
-        "Function <vkGetDeviceGroupSurfacePresentModesKHR> needs extension <VK_KHR_swapchain> enabled!" );
-
-      VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR modes;
-      VULKAN_HPP_NAMESPACE::Result                         result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetDeviceGroupSurfacePresentModesKHR(
-          static_cast<VkDevice>( m_device ),
-          static_cast<VkSurfaceKHR>( surface ),
-          reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR *>( &modes ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupSurfacePresentModesKHR" );
-      }
-      return modes;
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t Device::getMemoryOpaqueCaptureAddress(
-      const DeviceMemoryOpaqueCaptureAddressInfo & info ) const VULKAN_HPP_NOEXCEPT
-    {
-      return getDispatcher()->vkGetDeviceMemoryOpaqueCaptureAddress(
-        static_cast<VkDevice>( m_device ), reinterpret_cast<const VkDeviceMemoryOpaqueCaptureAddressInfo *>( &info ) );
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t Device::getMemoryOpaqueCaptureAddressKHR(
-      const DeviceMemoryOpaqueCaptureAddressInfo & info ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetDeviceMemoryOpaqueCaptureAddressKHR &&
-        "Function <vkGetDeviceMemoryOpaqueCaptureAddressKHR> needs extension <VK_KHR_buffer_device_address> enabled!" );
-
-      return getDispatcher()->vkGetDeviceMemoryOpaqueCaptureAddressKHR(
-        static_cast<VkDevice>( m_device ), reinterpret_cast<const VkDeviceMemoryOpaqueCaptureAddressInfo *>( &info ) );
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PFN_vkVoidFunction
-      Device::getProcAddr( const std::string & name ) const VULKAN_HPP_NOEXCEPT
-    {
-      return getDispatcher()->vkGetDeviceProcAddr( static_cast<VkDevice>( m_device ), name.c_str() );
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE int Device::getFenceFdKHR( const FenceGetFdInfoKHR & getFdInfo ) const
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkGetFenceFdKHR &&
-                         "Function <vkGetFenceFdKHR> needs extension <VK_KHR_external_fence_fd> enabled!" );
-
-      int                          fd;
-      VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetFenceFdKHR(
-        static_cast<VkDevice>( m_device ), reinterpret_cast<const VkFenceGetFdInfoKHR *>( &getFdInfo ), &fd ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getFenceFdKHR" );
-      }
-      return fd;
-    }
-
-#  if defined( VK_USE_PLATFORM_WIN32_KHR )
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE HANDLE
-      Device::getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR & getWin32HandleInfo ) const
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkGetFenceWin32HandleKHR &&
-                         "Function <vkGetFenceWin32HandleKHR> needs extension <VK_KHR_external_fence_win32> enabled!" );
-
-      HANDLE                       handle;
-      VULKAN_HPP_NAMESPACE::Result result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetFenceWin32HandleKHR(
-          static_cast<VkDevice>( m_device ),
-          reinterpret_cast<const VkFenceGetWin32HandleInfoKHR *>( &getWin32HandleInfo ),
-          &handle ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getFenceWin32HandleKHR" );
-      }
-      return handle;
-    }
-#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2
-      Device::getGeneratedCommandsMemoryRequirementsNV( const GeneratedCommandsMemoryRequirementsInfoNV & info ) const
-      VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetGeneratedCommandsMemoryRequirementsNV &&
-        "Function <vkGetGeneratedCommandsMemoryRequirementsNV> needs extension <VK_NV_device_generated_commands> enabled!" );
-
-      VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements;
-      getDispatcher()->vkGetGeneratedCommandsMemoryRequirementsNV(
-        static_cast<VkDevice>( m_device ),
-        reinterpret_cast<const VkGeneratedCommandsMemoryRequirementsInfoNV *>( &info ),
-        reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
-      return memoryRequirements;
-    }
-
-    template <typename X, typename Y, typename... Z>
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getGeneratedCommandsMemoryRequirementsNV(
-      const GeneratedCommandsMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetGeneratedCommandsMemoryRequirementsNV &&
-        "Function <vkGetGeneratedCommandsMemoryRequirementsNV> needs extension <VK_NV_device_generated_commands> enabled!" );
-
-      StructureChain<X, Y, Z...>                  structureChain;
-      VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements =
-        structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>();
-      getDispatcher()->vkGetGeneratedCommandsMemoryRequirementsNV(
-        static_cast<VkDevice>( m_device ),
-        reinterpret_cast<const VkGeneratedCommandsMemoryRequirementsInfoNV *>( &info ),
-        reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
-      return structureChain;
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2
-      Device::getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements;
-      getDispatcher()->vkGetImageMemoryRequirements2(
-        static_cast<VkDevice>( m_device ),
-        reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( &info ),
-        reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
-      return memoryRequirements;
-    }
-
-    template <typename X, typename Y, typename... Z>
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
-      Device::getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT
-    {
-      StructureChain<X, Y, Z...>                  structureChain;
-      VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements =
-        structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>();
-      getDispatcher()->vkGetImageMemoryRequirements2(
-        static_cast<VkDevice>( m_device ),
-        reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( &info ),
-        reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
-      return structureChain;
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2
-      Device::getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetImageMemoryRequirements2KHR &&
-        "Function <vkGetImageMemoryRequirements2KHR> needs extension <VK_KHR_get_memory_requirements2> enabled!" );
-
-      VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements;
-      getDispatcher()->vkGetImageMemoryRequirements2KHR(
-        static_cast<VkDevice>( m_device ),
-        reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( &info ),
-        reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
-      return memoryRequirements;
-    }
-
-    template <typename X, typename Y, typename... Z>
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...>
-      Device::getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetImageMemoryRequirements2KHR &&
-        "Function <vkGetImageMemoryRequirements2KHR> needs extension <VK_KHR_get_memory_requirements2> enabled!" );
-
-      StructureChain<X, Y, Z...>                  structureChain;
-      VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements =
-        structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>();
-      getDispatcher()->vkGetImageMemoryRequirements2KHR(
-        static_cast<VkDevice>( m_device ),
-        reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( &info ),
-        reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
-      return structureChain;
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>
-      Device::getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info ) const
-      VULKAN_HPP_NOEXCEPT
-    {
-      uint32_t sparseMemoryRequirementCount;
-      getDispatcher()->vkGetImageSparseMemoryRequirements2(
-        static_cast<VkDevice>( m_device ),
-        reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ),
-        &sparseMemoryRequirementCount,
-        nullptr );
-      std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2> sparseMemoryRequirements(
-        sparseMemoryRequirementCount );
-      getDispatcher()->vkGetImageSparseMemoryRequirements2(
-        static_cast<VkDevice>( m_device ),
-        reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ),
-        &sparseMemoryRequirementCount,
-        reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) );
-      VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() );
-      return sparseMemoryRequirements;
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>
-      Device::getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info ) const
-      VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetImageSparseMemoryRequirements2KHR &&
-        "Function <vkGetImageSparseMemoryRequirements2KHR> needs extension <VK_KHR_get_memory_requirements2> enabled!" );
-
-      uint32_t sparseMemoryRequirementCount;
-      getDispatcher()->vkGetImageSparseMemoryRequirements2KHR(
-        static_cast<VkDevice>( m_device ),
-        reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ),
-        &sparseMemoryRequirementCount,
-        nullptr );
-      std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2> sparseMemoryRequirements(
-        sparseMemoryRequirementCount );
-      getDispatcher()->vkGetImageSparseMemoryRequirements2KHR(
-        static_cast<VkDevice>( m_device ),
-        reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ),
-        &sparseMemoryRequirementCount,
-        reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) );
-      VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() );
-      return sparseMemoryRequirements;
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint32_t
-      Device::getImageViewHandleNVX( const ImageViewHandleInfoNVX & info ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageViewHandleNVX &&
-                         "Function <vkGetImageViewHandleNVX> needs extension <VK_NVX_image_view_handle> enabled!" );
-
-      return getDispatcher()->vkGetImageViewHandleNVX( static_cast<VkDevice>( m_device ),
-                                                       reinterpret_cast<const VkImageViewHandleInfoNVX *>( &info ) );
-    }
-
-#  if defined( VK_USE_PLATFORM_ANDROID_KHR )
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE struct AHardwareBuffer *
-      Device::getMemoryAndroidHardwareBufferANDROID( const MemoryGetAndroidHardwareBufferInfoANDROID & info ) const
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetMemoryAndroidHardwareBufferANDROID &&
-        "Function <vkGetMemoryAndroidHardwareBufferANDROID> needs extension <VK_ANDROID_external_memory_android_hardware_buffer> enabled!" );
-
-      struct AHardwareBuffer *     buffer;
-      VULKAN_HPP_NAMESPACE::Result result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetMemoryAndroidHardwareBufferANDROID(
-          static_cast<VkDevice>( m_device ),
-          reinterpret_cast<const VkMemoryGetAndroidHardwareBufferInfoANDROID *>( &info ),
-          &buffer ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryAndroidHardwareBufferANDROID" );
-      }
-      return buffer;
-    }
-#  endif /*VK_USE_PLATFORM_ANDROID_KHR*/
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE int Device::getMemoryFdKHR( const MemoryGetFdInfoKHR & getFdInfo ) const
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryFdKHR &&
-                         "Function <vkGetMemoryFdKHR> needs extension <VK_KHR_external_memory_fd> enabled!" );
-
-      int                          fd;
-      VULKAN_HPP_NAMESPACE::Result result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetMemoryFdKHR(
-          static_cast<VkDevice>( m_device ), reinterpret_cast<const VkMemoryGetFdInfoKHR *>( &getFdInfo ), &fd ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryFdKHR" );
-      }
-      return fd;
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR
-      Device::getMemoryFdPropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
-                                        int                                                    fd ) const
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryFdPropertiesKHR &&
-                         "Function <vkGetMemoryFdPropertiesKHR> needs extension <VK_KHR_external_memory_fd> enabled!" );
-
-      VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR memoryFdProperties;
-      VULKAN_HPP_NAMESPACE::Result                result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetMemoryFdPropertiesKHR(
-          static_cast<VkDevice>( m_device ),
-          static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ),
-          fd,
-          reinterpret_cast<VkMemoryFdPropertiesKHR *>( &memoryFdProperties ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryFdPropertiesKHR" );
-      }
-      return memoryFdProperties;
-    }
+    //=== VK_EXT_external_memory_host ===
 
     VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT
       Device::getMemoryHostPointerPropertiesEXT( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
@@ -10656,97 +13383,322 @@ namespace VULKAN_HPP_NAMESPACE
       return memoryHostPointerProperties;
     }
 
-#  if defined( VK_USE_PLATFORM_WIN32_KHR )
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE HANDLE
-      Device::getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR & getWin32HandleInfo ) const
+    //=== VK_AMD_buffer_marker ===
+
+    VULKAN_HPP_INLINE void
+      CommandBuffer::writeBufferMarkerAMD( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage,
+                                           VULKAN_HPP_NAMESPACE::Buffer                dstBuffer,
+                                           VULKAN_HPP_NAMESPACE::DeviceSize            dstOffset,
+                                           uint32_t marker ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdWriteBufferMarkerAMD &&
+                         "Function <vkCmdWriteBufferMarkerAMD> needs extension <VK_AMD_buffer_marker> enabled!" );
+
+      getDispatcher()->vkCmdWriteBufferMarkerAMD( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                                  static_cast<VkPipelineStageFlagBits>( pipelineStage ),
+                                                  static_cast<VkBuffer>( dstBuffer ),
+                                                  static_cast<VkDeviceSize>( dstOffset ),
+                                                  marker );
+    }
+
+    //=== VK_EXT_calibrated_timestamps ===
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::TimeDomainEXT>
+                                           PhysicalDevice::getCalibrateableTimeDomainsEXT() const
     {
       VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetMemoryWin32HandleKHR &&
-        "Function <vkGetMemoryWin32HandleKHR> needs extension <VK_KHR_external_memory_win32> enabled!" );
+        getDispatcher()->vkGetPhysicalDeviceCalibrateableTimeDomainsEXT &&
+        "Function <vkGetPhysicalDeviceCalibrateableTimeDomainsEXT> needs extension <VK_EXT_calibrated_timestamps> enabled!" );
 
-      HANDLE                       handle;
+      std::vector<VULKAN_HPP_NAMESPACE::TimeDomainEXT> timeDomains;
+      uint32_t                                         timeDomainCount;
+      VULKAN_HPP_NAMESPACE::Result                     result;
+      do
+      {
+        result =
+          static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(
+            static_cast<VkPhysicalDevice>( m_physicalDevice ), &timeDomainCount, nullptr ) );
+        if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && timeDomainCount )
+        {
+          timeDomains.resize( timeDomainCount );
+          result =
+            static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(
+              static_cast<VkPhysicalDevice>( m_physicalDevice ),
+              &timeDomainCount,
+              reinterpret_cast<VkTimeDomainEXT *>( timeDomains.data() ) ) );
+          VULKAN_HPP_ASSERT( timeDomainCount <= timeDomains.size() );
+        }
+      } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
+      if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( timeDomainCount < timeDomains.size() ) )
+      {
+        timeDomains.resize( timeDomainCount );
+      }
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCalibrateableTimeDomainsEXT" );
+      }
+      return timeDomains;
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<std::vector<uint64_t>, uint64_t>
+                                           Device::getCalibratedTimestampsEXT(
+        ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT> const & timestampInfos ) const
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkGetCalibratedTimestampsEXT &&
+        "Function <vkGetCalibratedTimestampsEXT> needs extension <VK_EXT_calibrated_timestamps> enabled!" );
+
+      std::pair<std::vector<uint64_t>, uint64_t> data(
+        std::piecewise_construct, std::forward_as_tuple( timestampInfos.size() ), std::forward_as_tuple( 0 ) );
+      std::vector<uint64_t> &      timestamps   = data.first;
+      uint64_t &                   maxDeviation = data.second;
       VULKAN_HPP_NAMESPACE::Result result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetMemoryWin32HandleKHR(
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetCalibratedTimestampsEXT(
           static_cast<VkDevice>( m_device ),
-          reinterpret_cast<const VkMemoryGetWin32HandleInfoKHR *>( &getWin32HandleInfo ),
-          &handle ) );
+          timestampInfos.size(),
+          reinterpret_cast<const VkCalibratedTimestampInfoEXT *>( timestampInfos.data() ),
+          timestamps.data(),
+          &maxDeviation ) );
       if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
       {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryWin32HandleKHR" );
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsEXT" );
       }
-      return handle;
+      return data;
     }
-#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
-#  if defined( VK_USE_PLATFORM_WIN32_KHR )
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR
-      Device::getMemoryWin32HandlePropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
-                                                 HANDLE                                                 handle ) const
+    //=== VK_NV_mesh_shader ===
+
+    VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksNV( uint32_t taskCount,
+                                                           uint32_t firstTask ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawMeshTasksNV &&
+                         "Function <vkCmdDrawMeshTasksNV> needs extension <VK_NV_mesh_shader> enabled!" );
+
+      getDispatcher()->vkCmdDrawMeshTasksNV( static_cast<VkCommandBuffer>( m_commandBuffer ), taskCount, firstTask );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectNV( VULKAN_HPP_NAMESPACE::Buffer     buffer,
+                                                                   VULKAN_HPP_NAMESPACE::DeviceSize offset,
+                                                                   uint32_t                         drawCount,
+                                                                   uint32_t stride ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawMeshTasksIndirectNV &&
+                         "Function <vkCmdDrawMeshTasksIndirectNV> needs extension <VK_NV_mesh_shader> enabled!" );
+
+      getDispatcher()->vkCmdDrawMeshTasksIndirectNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                                     static_cast<VkBuffer>( buffer ),
+                                                     static_cast<VkDeviceSize>( offset ),
+                                                     drawCount,
+                                                     stride );
+    }
+
+    VULKAN_HPP_INLINE void
+      CommandBuffer::drawMeshTasksIndirectCountNV( VULKAN_HPP_NAMESPACE::Buffer     buffer,
+                                                   VULKAN_HPP_NAMESPACE::DeviceSize offset,
+                                                   VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
+                                                   VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
+                                                   uint32_t                         maxDrawCount,
+                                                   uint32_t                         stride ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawMeshTasksIndirectCountNV &&
+                         "Function <vkCmdDrawMeshTasksIndirectCountNV> needs extension <VK_NV_mesh_shader> enabled!" );
+
+      getDispatcher()->vkCmdDrawMeshTasksIndirectCountNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                                          static_cast<VkBuffer>( buffer ),
+                                                          static_cast<VkDeviceSize>( offset ),
+                                                          static_cast<VkBuffer>( countBuffer ),
+                                                          static_cast<VkDeviceSize>( countBufferOffset ),
+                                                          maxDrawCount,
+                                                          stride );
+    }
+
+    //=== VK_NV_scissor_exclusive ===
+
+    VULKAN_HPP_INLINE void CommandBuffer::setExclusiveScissorNV(
+      uint32_t                                               firstExclusiveScissor,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & exclusiveScissors ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetExclusiveScissorNV &&
+                         "Function <vkCmdSetExclusiveScissorNV> needs extension <VK_NV_scissor_exclusive> enabled!" );
+
+      getDispatcher()->vkCmdSetExclusiveScissorNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                                   firstExclusiveScissor,
+                                                   exclusiveScissors.size(),
+                                                   reinterpret_cast<const VkRect2D *>( exclusiveScissors.data() ) );
+    }
+
+    //=== VK_NV_device_diagnostic_checkpoints ===
+
+    VULKAN_HPP_INLINE void CommandBuffer::setCheckpointNV( const void * pCheckpointMarker ) const VULKAN_HPP_NOEXCEPT
     {
       VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetMemoryWin32HandlePropertiesKHR &&
-        "Function <vkGetMemoryWin32HandlePropertiesKHR> needs extension <VK_KHR_external_memory_win32> enabled!" );
+        getDispatcher()->vkCmdSetCheckpointNV &&
+        "Function <vkCmdSetCheckpointNV> needs extension <VK_NV_device_diagnostic_checkpoints> enabled!" );
 
-      VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR memoryWin32HandleProperties;
-      VULKAN_HPP_NAMESPACE::Result                         result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetMemoryWin32HandlePropertiesKHR(
-          static_cast<VkDevice>( m_device ),
-          static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ),
-          handle,
-          reinterpret_cast<VkMemoryWin32HandlePropertiesKHR *>( &memoryWin32HandleProperties ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryWin32HandlePropertiesKHR" );
-      }
-      return memoryWin32HandleProperties;
+      getDispatcher()->vkCmdSetCheckpointNV( static_cast<VkCommandBuffer>( m_commandBuffer ), pCheckpointMarker );
     }
-#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
-#  if defined( VK_USE_PLATFORM_FUCHSIA )
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE zx_handle_t
-      Device::getMemoryZirconHandleFUCHSIA( const MemoryGetZirconHandleInfoFUCHSIA & getZirconHandleInfo ) const
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::CheckpointDataNV>
+                                           Queue::getCheckpointDataNV() const VULKAN_HPP_NOEXCEPT
     {
       VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetMemoryZirconHandleFUCHSIA &&
-        "Function <vkGetMemoryZirconHandleFUCHSIA> needs extension <VK_FUCHSIA_external_memory> enabled!" );
+        getDispatcher()->vkGetQueueCheckpointDataNV &&
+        "Function <vkGetQueueCheckpointDataNV> needs extension <VK_NV_device_diagnostic_checkpoints> enabled!" );
 
-      zx_handle_t                  zirconHandle;
+      uint32_t checkpointDataCount;
+      getDispatcher()->vkGetQueueCheckpointDataNV( static_cast<VkQueue>( m_queue ), &checkpointDataCount, nullptr );
+      std::vector<VULKAN_HPP_NAMESPACE::CheckpointDataNV> checkpointData( checkpointDataCount );
+      getDispatcher()->vkGetQueueCheckpointDataNV( static_cast<VkQueue>( m_queue ),
+                                                   &checkpointDataCount,
+                                                   reinterpret_cast<VkCheckpointDataNV *>( checkpointData.data() ) );
+      VULKAN_HPP_ASSERT( checkpointDataCount <= checkpointData.size() );
+      return checkpointData;
+    }
+
+    //=== VK_KHR_timeline_semaphore ===
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t Semaphore::getCounterValueKHR() const
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkGetSemaphoreCounterValueKHR &&
+        "Function <vkGetSemaphoreCounterValueKHR> needs extension <VK_KHR_timeline_semaphore> enabled!" );
+
+      uint64_t                     value;
       VULKAN_HPP_NAMESPACE::Result result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetMemoryZirconHandleFUCHSIA(
-          static_cast<VkDevice>( m_device ),
-          reinterpret_cast<const VkMemoryGetZirconHandleInfoFUCHSIA *>( &getZirconHandleInfo ),
-          &zirconHandle ) );
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetSemaphoreCounterValueKHR(
+          static_cast<VkDevice>( m_device ), static_cast<VkSemaphore>( m_semaphore ), &value ) );
       if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
       {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryZirconHandleFUCHSIA" );
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Semaphore::getCounterValueKHR" );
       }
-      return zirconHandle;
+      return value;
     }
-#  endif /*VK_USE_PLATFORM_FUCHSIA*/
 
-#  if defined( VK_USE_PLATFORM_FUCHSIA )
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA
-      Device::getMemoryZirconHandlePropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
-                                                      zx_handle_t zirconHandle ) const
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result
+      Device::waitSemaphoresKHR( const SemaphoreWaitInfo & waitInfo, uint64_t timeout ) const
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkWaitSemaphoresKHR &&
+                         "Function <vkWaitSemaphoresKHR> needs extension <VK_KHR_timeline_semaphore> enabled!" );
+
+      VULKAN_HPP_NAMESPACE::Result result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkWaitSemaphoresKHR(
+          static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSemaphoreWaitInfo *>( &waitInfo ), timeout ) );
+      if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) &&
+           ( result != VULKAN_HPP_NAMESPACE::Result::eTimeout ) )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::waitSemaphoresKHR" );
+      }
+      return result;
+    }
+
+    VULKAN_HPP_INLINE void Device::signalSemaphoreKHR( const SemaphoreSignalInfo & signalInfo ) const
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkSignalSemaphoreKHR &&
+                         "Function <vkSignalSemaphoreKHR> needs extension <VK_KHR_timeline_semaphore> enabled!" );
+
+      VULKAN_HPP_NAMESPACE::Result result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkSignalSemaphoreKHR(
+          static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSemaphoreSignalInfo *>( &signalInfo ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::signalSemaphoreKHR" );
+      }
+    }
+
+    //=== VK_INTEL_performance_query ===
+
+    VULKAN_HPP_INLINE void
+      Device::initializePerformanceApiINTEL( const InitializePerformanceApiInfoINTEL & initializeInfo ) const
     {
       VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetMemoryZirconHandlePropertiesFUCHSIA &&
-        "Function <vkGetMemoryZirconHandlePropertiesFUCHSIA> needs extension <VK_FUCHSIA_external_memory> enabled!" );
+        getDispatcher()->vkInitializePerformanceApiINTEL &&
+        "Function <vkInitializePerformanceApiINTEL> needs extension <VK_INTEL_performance_query> enabled!" );
 
-      VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA memoryZirconHandleProperties;
-      VULKAN_HPP_NAMESPACE::Result                              result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetMemoryZirconHandlePropertiesFUCHSIA(
+      VULKAN_HPP_NAMESPACE::Result result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkInitializePerformanceApiINTEL(
           static_cast<VkDevice>( m_device ),
-          static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ),
-          zirconHandle,
-          reinterpret_cast<VkMemoryZirconHandlePropertiesFUCHSIA *>( &memoryZirconHandleProperties ) ) );
+          reinterpret_cast<const VkInitializePerformanceApiInfoINTEL *>( &initializeInfo ) ) );
       if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
       {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryZirconHandlePropertiesFUCHSIA" );
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::initializePerformanceApiINTEL" );
+      }
+    }
+
+    VULKAN_HPP_INLINE void Device::uninitializePerformanceApiINTEL() const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkUninitializePerformanceApiINTEL &&
+        "Function <vkUninitializePerformanceApiINTEL> needs extension <VK_INTEL_performance_query> enabled!" );
+
+      getDispatcher()->vkUninitializePerformanceApiINTEL( static_cast<VkDevice>( m_device ) );
+    }
+
+    VULKAN_HPP_INLINE void
+      CommandBuffer::setPerformanceMarkerINTEL( const PerformanceMarkerInfoINTEL & markerInfo ) const
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkCmdSetPerformanceMarkerINTEL &&
+        "Function <vkCmdSetPerformanceMarkerINTEL> needs extension <VK_INTEL_performance_query> enabled!" );
+
+      VULKAN_HPP_NAMESPACE::Result result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCmdSetPerformanceMarkerINTEL(
+          static_cast<VkCommandBuffer>( m_commandBuffer ),
+          reinterpret_cast<const VkPerformanceMarkerInfoINTEL *>( &markerInfo ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setPerformanceMarkerINTEL" );
+      }
+    }
+
+    VULKAN_HPP_INLINE void
+      CommandBuffer::setPerformanceStreamMarkerINTEL( const PerformanceStreamMarkerInfoINTEL & markerInfo ) const
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkCmdSetPerformanceStreamMarkerINTEL &&
+        "Function <vkCmdSetPerformanceStreamMarkerINTEL> needs extension <VK_INTEL_performance_query> enabled!" );
+
+      VULKAN_HPP_NAMESPACE::Result result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCmdSetPerformanceStreamMarkerINTEL(
+          static_cast<VkCommandBuffer>( m_commandBuffer ),
+          reinterpret_cast<const VkPerformanceStreamMarkerInfoINTEL *>( &markerInfo ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setPerformanceStreamMarkerINTEL" );
+      }
+    }
+
+    VULKAN_HPP_INLINE void
+      CommandBuffer::setPerformanceOverrideINTEL( const PerformanceOverrideInfoINTEL & overrideInfo ) const
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkCmdSetPerformanceOverrideINTEL &&
+        "Function <vkCmdSetPerformanceOverrideINTEL> needs extension <VK_INTEL_performance_query> enabled!" );
+
+      VULKAN_HPP_NAMESPACE::Result result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCmdSetPerformanceOverrideINTEL(
+          static_cast<VkCommandBuffer>( m_commandBuffer ),
+          reinterpret_cast<const VkPerformanceOverrideInfoINTEL *>( &overrideInfo ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setPerformanceOverrideINTEL" );
+      }
+    }
+
+    VULKAN_HPP_INLINE void
+      Queue::setPerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration ) const
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkQueueSetPerformanceConfigurationINTEL &&
+        "Function <vkQueueSetPerformanceConfigurationINTEL> needs extension <VK_INTEL_performance_query> enabled!" );
+
+      VULKAN_HPP_NAMESPACE::Result result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkQueueSetPerformanceConfigurationINTEL(
+          static_cast<VkQueue>( m_queue ), static_cast<VkPerformanceConfigurationINTEL>( configuration ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::setPerformanceConfigurationINTEL" );
       }
-      return memoryZirconHandleProperties;
     }
-#  endif /*VK_USE_PLATFORM_FUCHSIA*/
 
     VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PerformanceValueINTEL
       Device::getPerformanceParameterINTEL( VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL parameter ) const
@@ -10767,50 +13719,569 @@ namespace VULKAN_HPP_NAMESPACE
       return value;
     }
 
-    VULKAN_HPP_NODISCARD
-      VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR>
-      Device::getPipelineExecutableInternalRepresentationsKHR( const PipelineExecutableInfoKHR & executableInfo ) const
+    //=== VK_AMD_display_native_hdr ===
+
+    VULKAN_HPP_INLINE void
+      SwapchainKHR::setLocalDimmingAMD( VULKAN_HPP_NAMESPACE::Bool32 localDimmingEnable ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkSetLocalDimmingAMD &&
+                         "Function <vkSetLocalDimmingAMD> needs extension <VK_AMD_display_native_hdr> enabled!" );
+
+      getDispatcher()->vkSetLocalDimmingAMD( static_cast<VkDevice>( m_device ),
+                                             static_cast<VkSwapchainKHR>( m_swapchainKHR ),
+                                             static_cast<VkBool32>( localDimmingEnable ) );
+    }
+
+    //=== VK_KHR_fragment_shading_rate ===
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR>
+                                           PhysicalDevice::getFragmentShadingRatesKHR() const
     {
       VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetPipelineExecutableInternalRepresentationsKHR &&
-        "Function <vkGetPipelineExecutableInternalRepresentationsKHR> needs extension <VK_KHR_pipeline_executable_properties> enabled!" );
+        getDispatcher()->vkGetPhysicalDeviceFragmentShadingRatesKHR &&
+        "Function <vkGetPhysicalDeviceFragmentShadingRatesKHR> needs extension <VK_KHR_fragment_shading_rate> enabled!" );
 
-      std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR> internalRepresentations;
-      uint32_t                                                                       internalRepresentationCount;
-      VULKAN_HPP_NAMESPACE::Result                                                   result;
+      std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR> fragmentShadingRates;
+      uint32_t                                                                fragmentShadingRateCount;
+      VULKAN_HPP_NAMESPACE::Result                                            result;
       do
       {
-        result =
-          static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPipelineExecutableInternalRepresentationsKHR(
-            static_cast<VkDevice>( m_device ),
-            reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ),
-            &internalRepresentationCount,
-            nullptr ) );
-        if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && internalRepresentationCount )
+        result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceFragmentShadingRatesKHR(
+          static_cast<VkPhysicalDevice>( m_physicalDevice ), &fragmentShadingRateCount, nullptr ) );
+        if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && fragmentShadingRateCount )
         {
-          internalRepresentations.resize( internalRepresentationCount );
-          result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-            getDispatcher()->vkGetPipelineExecutableInternalRepresentationsKHR(
-              static_cast<VkDevice>( m_device ),
-              reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ),
-              &internalRepresentationCount,
-              reinterpret_cast<VkPipelineExecutableInternalRepresentationKHR *>( internalRepresentations.data() ) ) );
-          VULKAN_HPP_ASSERT( internalRepresentationCount <= internalRepresentations.size() );
+          fragmentShadingRates.resize( fragmentShadingRateCount );
+          result =
+            static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceFragmentShadingRatesKHR(
+              static_cast<VkPhysicalDevice>( m_physicalDevice ),
+              &fragmentShadingRateCount,
+              reinterpret_cast<VkPhysicalDeviceFragmentShadingRateKHR *>( fragmentShadingRates.data() ) ) );
+          VULKAN_HPP_ASSERT( fragmentShadingRateCount <= fragmentShadingRates.size() );
         }
       } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
       if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) &&
-           ( internalRepresentationCount < internalRepresentations.size() ) )
+           ( fragmentShadingRateCount < fragmentShadingRates.size() ) )
       {
-        internalRepresentations.resize( internalRepresentationCount );
+        fragmentShadingRates.resize( fragmentShadingRateCount );
+      }
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getFragmentShadingRatesKHR" );
+      }
+      return fragmentShadingRates;
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::setFragmentShadingRateKHR(
+      const Extent2D &                                             fragmentSize,
+      const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2] ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkCmdSetFragmentShadingRateKHR &&
+        "Function <vkCmdSetFragmentShadingRateKHR> needs extension <VK_KHR_fragment_shading_rate> enabled!" );
+
+      getDispatcher()->vkCmdSetFragmentShadingRateKHR(
+        static_cast<VkCommandBuffer>( m_commandBuffer ),
+        reinterpret_cast<const VkExtent2D *>( &fragmentSize ),
+        reinterpret_cast<const VkFragmentShadingRateCombinerOpKHR *>( combinerOps ) );
+    }
+
+    //=== VK_EXT_buffer_device_address ===
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceAddress
+      Device::getBufferAddressEXT( const BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkGetBufferDeviceAddressEXT &&
+        "Function <vkGetBufferDeviceAddressEXT> needs extension <VK_EXT_buffer_device_address> enabled!" );
+
+      return static_cast<VULKAN_HPP_NAMESPACE::DeviceAddress>( getDispatcher()->vkGetBufferDeviceAddressEXT(
+        static_cast<VkDevice>( m_device ), reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) ) );
+    }
+
+    //=== VK_EXT_tooling_info ===
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolPropertiesEXT>
+                                           PhysicalDevice::getToolPropertiesEXT() const
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkGetPhysicalDeviceToolPropertiesEXT &&
+        "Function <vkGetPhysicalDeviceToolPropertiesEXT> needs extension <VK_EXT_tooling_info> enabled!" );
+
+      std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolPropertiesEXT> toolProperties;
+      uint32_t                                                           toolCount;
+      VULKAN_HPP_NAMESPACE::Result                                       result;
+      do
+      {
+        result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceToolPropertiesEXT(
+          static_cast<VkPhysicalDevice>( m_physicalDevice ), &toolCount, nullptr ) );
+        if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && toolCount )
+        {
+          toolProperties.resize( toolCount );
+          result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceToolPropertiesEXT(
+            static_cast<VkPhysicalDevice>( m_physicalDevice ),
+            &toolCount,
+            reinterpret_cast<VkPhysicalDeviceToolPropertiesEXT *>( toolProperties.data() ) ) );
+          VULKAN_HPP_ASSERT( toolCount <= toolProperties.size() );
+        }
+      } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
+      if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( toolCount < toolProperties.size() ) )
+      {
+        toolProperties.resize( toolCount );
+      }
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getToolPropertiesEXT" );
+      }
+      return toolProperties;
+    }
+
+    //=== VK_NV_cooperative_matrix ===
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV>
+                                           PhysicalDevice::getCooperativeMatrixPropertiesNV() const
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkGetPhysicalDeviceCooperativeMatrixPropertiesNV &&
+        "Function <vkGetPhysicalDeviceCooperativeMatrixPropertiesNV> needs extension <VK_NV_cooperative_matrix> enabled!" );
+
+      std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV> properties;
+      uint32_t                                                         propertyCount;
+      VULKAN_HPP_NAMESPACE::Result                                     result;
+      do
+      {
+        result =
+          static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(
+            static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, nullptr ) );
+        if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount )
+        {
+          properties.resize( propertyCount );
+          result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
+            getDispatcher()->vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(
+              static_cast<VkPhysicalDevice>( m_physicalDevice ),
+              &propertyCount,
+              reinterpret_cast<VkCooperativeMatrixPropertiesNV *>( properties.data() ) ) );
+          VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+        }
+      } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
+      if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( propertyCount < properties.size() ) )
+      {
+        properties.resize( propertyCount );
       }
       if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
       {
         throwResultException( result,
-                              VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutableInternalRepresentationsKHR" );
+                              VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCooperativeMatrixPropertiesNV" );
       }
-      return internalRepresentations;
+      return properties;
     }
 
+    //=== VK_NV_coverage_reduction_mode ===
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV>
+                                           PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV() const
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV &&
+        "Function <vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV> needs extension <VK_NV_coverage_reduction_mode> enabled!" );
+
+      std::vector<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV> combinations;
+      uint32_t                                                                combinationCount;
+      VULKAN_HPP_NAMESPACE::Result                                            result;
+      do
+      {
+        result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
+          getDispatcher()->vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
+            static_cast<VkPhysicalDevice>( m_physicalDevice ), &combinationCount, nullptr ) );
+        if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && combinationCount )
+        {
+          combinations.resize( combinationCount );
+          result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
+            getDispatcher()->vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
+              static_cast<VkPhysicalDevice>( m_physicalDevice ),
+              &combinationCount,
+              reinterpret_cast<VkFramebufferMixedSamplesCombinationNV *>( combinations.data() ) ) );
+          VULKAN_HPP_ASSERT( combinationCount <= combinations.size() );
+        }
+      } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
+      if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( combinationCount < combinations.size() ) )
+      {
+        combinations.resize( combinationCount );
+      }
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException(
+          result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV" );
+      }
+      return combinations;
+    }
+
+#  if defined( VK_USE_PLATFORM_WIN32_KHR )
+    //=== VK_EXT_full_screen_exclusive ===
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR>
+      PhysicalDevice::getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkGetPhysicalDeviceSurfacePresentModes2EXT &&
+        "Function <vkGetPhysicalDeviceSurfacePresentModes2EXT> needs extension <VK_EXT_full_screen_exclusive> enabled!" );
+
+      std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR> presentModes;
+      uint32_t                                          presentModeCount;
+      VULKAN_HPP_NAMESPACE::Result                      result;
+      do
+      {
+        result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceSurfacePresentModes2EXT(
+          static_cast<VkPhysicalDevice>( m_physicalDevice ),
+          reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
+          &presentModeCount,
+          nullptr ) );
+        if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && presentModeCount )
+        {
+          presentModes.resize( presentModeCount );
+          result =
+            static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceSurfacePresentModes2EXT(
+              static_cast<VkPhysicalDevice>( m_physicalDevice ),
+              reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
+              &presentModeCount,
+              reinterpret_cast<VkPresentModeKHR *>( presentModes.data() ) ) );
+          VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() );
+        }
+      } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
+      if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( presentModeCount < presentModes.size() ) )
+      {
+        presentModes.resize( presentModeCount );
+      }
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfacePresentModes2EXT" );
+      }
+      return presentModes;
+    }
+
+    VULKAN_HPP_INLINE void SwapchainKHR::acquireFullScreenExclusiveModeEXT() const
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkAcquireFullScreenExclusiveModeEXT &&
+        "Function <vkAcquireFullScreenExclusiveModeEXT> needs extension <VK_EXT_full_screen_exclusive> enabled!" );
+
+      VULKAN_HPP_NAMESPACE::Result result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkAcquireFullScreenExclusiveModeEXT(
+          static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchainKHR ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::acquireFullScreenExclusiveModeEXT" );
+      }
+    }
+
+    VULKAN_HPP_INLINE void SwapchainKHR::releaseFullScreenExclusiveModeEXT() const
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkReleaseFullScreenExclusiveModeEXT &&
+        "Function <vkReleaseFullScreenExclusiveModeEXT> needs extension <VK_EXT_full_screen_exclusive> enabled!" );
+
+      VULKAN_HPP_NAMESPACE::Result result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkReleaseFullScreenExclusiveModeEXT(
+          static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchainKHR ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::releaseFullScreenExclusiveModeEXT" );
+      }
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR
+      Device::getGroupSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkGetDeviceGroupSurfacePresentModes2EXT &&
+        "Function <vkGetDeviceGroupSurfacePresentModes2EXT> needs extension <VK_EXT_full_screen_exclusive> enabled!" );
+
+      VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR modes;
+      VULKAN_HPP_NAMESPACE::Result                         result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetDeviceGroupSurfacePresentModes2EXT(
+          static_cast<VkDevice>( m_device ),
+          reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
+          reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR *>( &modes ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupSurfacePresentModes2EXT" );
+      }
+      return modes;
+    }
+#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+    //=== VK_KHR_buffer_device_address ===
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceAddress
+      Device::getBufferAddressKHR( const BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkGetBufferDeviceAddressKHR &&
+        "Function <vkGetBufferDeviceAddressKHR> needs extension <VK_KHR_buffer_device_address> enabled!" );
+
+      return static_cast<VULKAN_HPP_NAMESPACE::DeviceAddress>( getDispatcher()->vkGetBufferDeviceAddressKHR(
+        static_cast<VkDevice>( m_device ), reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) ) );
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t
+      Device::getBufferOpaqueCaptureAddressKHR( const BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkGetBufferOpaqueCaptureAddressKHR &&
+        "Function <vkGetBufferOpaqueCaptureAddressKHR> needs extension <VK_KHR_buffer_device_address> enabled!" );
+
+      return getDispatcher()->vkGetBufferOpaqueCaptureAddressKHR(
+        static_cast<VkDevice>( m_device ), reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) );
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t Device::getMemoryOpaqueCaptureAddressKHR(
+      const DeviceMemoryOpaqueCaptureAddressInfo & info ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkGetDeviceMemoryOpaqueCaptureAddressKHR &&
+        "Function <vkGetDeviceMemoryOpaqueCaptureAddressKHR> needs extension <VK_KHR_buffer_device_address> enabled!" );
+
+      return getDispatcher()->vkGetDeviceMemoryOpaqueCaptureAddressKHR(
+        static_cast<VkDevice>( m_device ), reinterpret_cast<const VkDeviceMemoryOpaqueCaptureAddressInfo *>( &info ) );
+    }
+
+    //=== VK_EXT_line_rasterization ===
+
+    VULKAN_HPP_INLINE void CommandBuffer::setLineStippleEXT( uint32_t lineStippleFactor,
+                                                             uint16_t lineStipplePattern ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetLineStippleEXT &&
+                         "Function <vkCmdSetLineStippleEXT> needs extension <VK_EXT_line_rasterization> enabled!" );
+
+      getDispatcher()->vkCmdSetLineStippleEXT(
+        static_cast<VkCommandBuffer>( m_commandBuffer ), lineStippleFactor, lineStipplePattern );
+    }
+
+    //=== VK_EXT_host_query_reset ===
+
+    VULKAN_HPP_INLINE void QueryPool::resetEXT( uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkResetQueryPoolEXT &&
+                         "Function <vkResetQueryPoolEXT> needs extension <VK_EXT_host_query_reset> enabled!" );
+
+      getDispatcher()->vkResetQueryPoolEXT(
+        static_cast<VkDevice>( m_device ), static_cast<VkQueryPool>( m_queryPool ), firstQuery, queryCount );
+    }
+
+    //=== VK_EXT_extended_dynamic_state ===
+
+    VULKAN_HPP_INLINE void
+      CommandBuffer::setCullModeEXT( VULKAN_HPP_NAMESPACE::CullModeFlags cullMode ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetCullModeEXT &&
+                         "Function <vkCmdSetCullModeEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!" );
+
+      getDispatcher()->vkCmdSetCullModeEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                            static_cast<VkCullModeFlags>( cullMode ) );
+    }
+
+    VULKAN_HPP_INLINE void
+      CommandBuffer::setFrontFaceEXT( VULKAN_HPP_NAMESPACE::FrontFace frontFace ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetFrontFaceEXT &&
+                         "Function <vkCmdSetFrontFaceEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!" );
+
+      getDispatcher()->vkCmdSetFrontFaceEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                             static_cast<VkFrontFace>( frontFace ) );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::setPrimitiveTopologyEXT(
+      VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkCmdSetPrimitiveTopologyEXT &&
+        "Function <vkCmdSetPrimitiveTopologyEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!" );
+
+      getDispatcher()->vkCmdSetPrimitiveTopologyEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                                     static_cast<VkPrimitiveTopology>( primitiveTopology ) );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::setViewportWithCountEXT(
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkCmdSetViewportWithCountEXT &&
+        "Function <vkCmdSetViewportWithCountEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!" );
+
+      getDispatcher()->vkCmdSetViewportWithCountEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                                     viewports.size(),
+                                                     reinterpret_cast<const VkViewport *>( viewports.data() ) );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::setScissorWithCountEXT(
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkCmdSetScissorWithCountEXT &&
+        "Function <vkCmdSetScissorWithCountEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!" );
+
+      getDispatcher()->vkCmdSetScissorWithCountEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                                    scissors.size(),
+                                                    reinterpret_cast<const VkRect2D *>( scissors.data() ) );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers2EXT(
+      uint32_t                                                   firstBinding,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &     buffers,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & strides ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkCmdBindVertexBuffers2EXT &&
+        "Function <vkCmdBindVertexBuffers2EXT> needs extension <VK_EXT_extended_dynamic_state> enabled!" );
+
+#  ifdef VULKAN_HPP_NO_EXCEPTIONS
+      VULKAN_HPP_ASSERT( buffers.size() == offsets.size() );
+      VULKAN_HPP_ASSERT( sizes.empty() || buffers.size() == sizes.size() );
+      VULKAN_HPP_ASSERT( strides.empty() || buffers.size() == strides.size() );
+#  else
+      if ( buffers.size() != offsets.size() )
+      {
+        throw LogicError( VULKAN_HPP_NAMESPACE_STRING
+                          "::CommandBuffer::bindVertexBuffers2EXT: buffers.size() != offsets.size()" );
+      }
+      if ( !sizes.empty() && buffers.size() != sizes.size() )
+      {
+        throw LogicError( VULKAN_HPP_NAMESPACE_STRING
+                          "::CommandBuffer::bindVertexBuffers2EXT: buffers.size() != sizes.size()" );
+      }
+      if ( !strides.empty() && buffers.size() != strides.size() )
+      {
+        throw LogicError( VULKAN_HPP_NAMESPACE_STRING
+                          "::CommandBuffer::bindVertexBuffers2EXT: buffers.size() != strides.size()" );
+      }
+#  endif /*VULKAN_HPP_NO_EXCEPTIONS*/
+
+      getDispatcher()->vkCmdBindVertexBuffers2EXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                                   firstBinding,
+                                                   buffers.size(),
+                                                   reinterpret_cast<const VkBuffer *>( buffers.data() ),
+                                                   reinterpret_cast<const VkDeviceSize *>( offsets.data() ),
+                                                   reinterpret_cast<const VkDeviceSize *>( sizes.data() ),
+                                                   reinterpret_cast<const VkDeviceSize *>( strides.data() ) );
+    }
+
+    VULKAN_HPP_INLINE void
+      CommandBuffer::setDepthTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkCmdSetDepthTestEnableEXT &&
+        "Function <vkCmdSetDepthTestEnableEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!" );
+
+      getDispatcher()->vkCmdSetDepthTestEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                                   static_cast<VkBool32>( depthTestEnable ) );
+    }
+
+    VULKAN_HPP_INLINE void
+      CommandBuffer::setDepthWriteEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkCmdSetDepthWriteEnableEXT &&
+        "Function <vkCmdSetDepthWriteEnableEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!" );
+
+      getDispatcher()->vkCmdSetDepthWriteEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                                    static_cast<VkBool32>( depthWriteEnable ) );
+    }
+
+    VULKAN_HPP_INLINE void
+      CommandBuffer::setDepthCompareOpEXT( VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkCmdSetDepthCompareOpEXT &&
+        "Function <vkCmdSetDepthCompareOpEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!" );
+
+      getDispatcher()->vkCmdSetDepthCompareOpEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                                  static_cast<VkCompareOp>( depthCompareOp ) );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::setDepthBoundsTestEnableEXT(
+      VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkCmdSetDepthBoundsTestEnableEXT &&
+        "Function <vkCmdSetDepthBoundsTestEnableEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!" );
+
+      getDispatcher()->vkCmdSetDepthBoundsTestEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                                         static_cast<VkBool32>( depthBoundsTestEnable ) );
+    }
+
+    VULKAN_HPP_INLINE void
+      CommandBuffer::setStencilTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkCmdSetStencilTestEnableEXT &&
+        "Function <vkCmdSetStencilTestEnableEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!" );
+
+      getDispatcher()->vkCmdSetStencilTestEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                                     static_cast<VkBool32>( stencilTestEnable ) );
+    }
+
+    VULKAN_HPP_INLINE void
+      CommandBuffer::setStencilOpEXT( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
+                                      VULKAN_HPP_NAMESPACE::StencilOp        failOp,
+                                      VULKAN_HPP_NAMESPACE::StencilOp        passOp,
+                                      VULKAN_HPP_NAMESPACE::StencilOp        depthFailOp,
+                                      VULKAN_HPP_NAMESPACE::CompareOp        compareOp ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetStencilOpEXT &&
+                         "Function <vkCmdSetStencilOpEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!" );
+
+      getDispatcher()->vkCmdSetStencilOpEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                             static_cast<VkStencilFaceFlags>( faceMask ),
+                                             static_cast<VkStencilOp>( failOp ),
+                                             static_cast<VkStencilOp>( passOp ),
+                                             static_cast<VkStencilOp>( depthFailOp ),
+                                             static_cast<VkCompareOp>( compareOp ) );
+    }
+
+    //=== VK_KHR_deferred_host_operations ===
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint32_t DeferredOperationKHR::getMaxConcurrency() const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkGetDeferredOperationMaxConcurrencyKHR &&
+        "Function <vkGetDeferredOperationMaxConcurrencyKHR> needs extension <VK_KHR_deferred_host_operations> enabled!" );
+
+      return getDispatcher()->vkGetDeferredOperationMaxConcurrencyKHR(
+        static_cast<VkDevice>( m_device ), static_cast<VkDeferredOperationKHR>( m_deferredOperationKHR ) );
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result
+                                           DeferredOperationKHR::getResult() const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkGetDeferredOperationResultKHR &&
+        "Function <vkGetDeferredOperationResultKHR> needs extension <VK_KHR_deferred_host_operations> enabled!" );
+
+      return static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetDeferredOperationResultKHR(
+        static_cast<VkDevice>( m_device ), static_cast<VkDeferredOperationKHR>( m_deferredOperationKHR ) ) );
+    }
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result DeferredOperationKHR::join() const
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkDeferredOperationJoinKHR &&
+        "Function <vkDeferredOperationJoinKHR> needs extension <VK_KHR_deferred_host_operations> enabled!" );
+
+      VULKAN_HPP_NAMESPACE::Result result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkDeferredOperationJoinKHR(
+          static_cast<VkDevice>( m_device ), static_cast<VkDeferredOperationKHR>( m_deferredOperationKHR ) ) );
+      if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) &&
+           ( result != VULKAN_HPP_NAMESPACE::Result::eThreadDoneKHR ) &&
+           ( result != VULKAN_HPP_NAMESPACE::Result::eThreadIdleKHR ) )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::DeferredOperationKHR::join" );
+      }
+      return result;
+    }
+
+    //=== VK_KHR_pipeline_executable_properties ===
+
     VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR>
       Device::getPipelineExecutablePropertiesKHR( const PipelineInfoKHR & pipelineInfo ) const
     {
@@ -10889,271 +14360,129 @@ namespace VULKAN_HPP_NAMESPACE
       return statistics;
     }
 
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t
-      Device::getPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType         objectType_,
-                                 uint64_t                                 objectHandle,
-                                 VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkGetPrivateDataEXT &&
-                         "Function <vkGetPrivateDataEXT> needs extension <VK_EXT_private_data> enabled!" );
-
-      uint64_t data;
-      getDispatcher()->vkGetPrivateDataEXT( static_cast<VkDevice>( m_device ),
-                                            static_cast<VkObjectType>( objectType_ ),
-                                            objectHandle,
-                                            static_cast<VkPrivateDataSlotEXT>( privateDataSlot ),
-                                            &data );
-      return data;
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE int
-      Device::getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR & getFdInfo ) const
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkGetSemaphoreFdKHR &&
-                         "Function <vkGetSemaphoreFdKHR> needs extension <VK_KHR_external_semaphore_fd> enabled!" );
-
-      int                          fd;
-      VULKAN_HPP_NAMESPACE::Result result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetSemaphoreFdKHR(
-          static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSemaphoreGetFdInfoKHR *>( &getFdInfo ), &fd ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreFdKHR" );
-      }
-      return fd;
-    }
-
-#  if defined( VK_USE_PLATFORM_WIN32_KHR )
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE HANDLE
-      Device::getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo ) const
+    VULKAN_HPP_NODISCARD
+      VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR>
+      Device::getPipelineExecutableInternalRepresentationsKHR( const PipelineExecutableInfoKHR & executableInfo ) const
     {
       VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetSemaphoreWin32HandleKHR &&
-        "Function <vkGetSemaphoreWin32HandleKHR> needs extension <VK_KHR_external_semaphore_win32> enabled!" );
+        getDispatcher()->vkGetPipelineExecutableInternalRepresentationsKHR &&
+        "Function <vkGetPipelineExecutableInternalRepresentationsKHR> needs extension <VK_KHR_pipeline_executable_properties> enabled!" );
 
-      HANDLE                       handle;
-      VULKAN_HPP_NAMESPACE::Result result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetSemaphoreWin32HandleKHR(
-          static_cast<VkDevice>( m_device ),
-          reinterpret_cast<const VkSemaphoreGetWin32HandleInfoKHR *>( &getWin32HandleInfo ),
-          &handle ) );
+      std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR> internalRepresentations;
+      uint32_t                                                                       internalRepresentationCount;
+      VULKAN_HPP_NAMESPACE::Result                                                   result;
+      do
+      {
+        result =
+          static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPipelineExecutableInternalRepresentationsKHR(
+            static_cast<VkDevice>( m_device ),
+            reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ),
+            &internalRepresentationCount,
+            nullptr ) );
+        if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && internalRepresentationCount )
+        {
+          internalRepresentations.resize( internalRepresentationCount );
+          result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
+            getDispatcher()->vkGetPipelineExecutableInternalRepresentationsKHR(
+              static_cast<VkDevice>( m_device ),
+              reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ),
+              &internalRepresentationCount,
+              reinterpret_cast<VkPipelineExecutableInternalRepresentationKHR *>( internalRepresentations.data() ) ) );
+          VULKAN_HPP_ASSERT( internalRepresentationCount <= internalRepresentations.size() );
+        }
+      } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
+      if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) &&
+           ( internalRepresentationCount < internalRepresentations.size() ) )
+      {
+        internalRepresentations.resize( internalRepresentationCount );
+      }
       if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
       {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreWin32HandleKHR" );
+        throwResultException( result,
+                              VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutableInternalRepresentationsKHR" );
       }
-      return handle;
+      return internalRepresentations;
     }
-#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
-#  if defined( VK_USE_PLATFORM_FUCHSIA )
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE zx_handle_t
-      Device::getSemaphoreZirconHandleFUCHSIA( const SemaphoreGetZirconHandleInfoFUCHSIA & getZirconHandleInfo ) const
+    //=== VK_NV_device_generated_commands ===
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2
+      Device::getGeneratedCommandsMemoryRequirementsNV( const GeneratedCommandsMemoryRequirementsInfoNV & info ) const
+      VULKAN_HPP_NOEXCEPT
     {
       VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetSemaphoreZirconHandleFUCHSIA &&
-        "Function <vkGetSemaphoreZirconHandleFUCHSIA> needs extension <VK_FUCHSIA_external_semaphore> enabled!" );
+        getDispatcher()->vkGetGeneratedCommandsMemoryRequirementsNV &&
+        "Function <vkGetGeneratedCommandsMemoryRequirementsNV> needs extension <VK_NV_device_generated_commands> enabled!" );
 
-      zx_handle_t                  zirconHandle;
-      VULKAN_HPP_NAMESPACE::Result result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetSemaphoreZirconHandleFUCHSIA(
-          static_cast<VkDevice>( m_device ),
-          reinterpret_cast<const VkSemaphoreGetZirconHandleInfoFUCHSIA *>( &getZirconHandleInfo ),
-          &zirconHandle ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreZirconHandleFUCHSIA" );
-      }
-      return zirconHandle;
-    }
-#  endif /*VK_USE_PLATFORM_FUCHSIA*/
-
-    VULKAN_HPP_INLINE void Device::importFenceFdKHR( const ImportFenceFdInfoKHR & importFenceFdInfo ) const
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkImportFenceFdKHR &&
-                         "Function <vkImportFenceFdKHR> needs extension <VK_KHR_external_fence_fd> enabled!" );
-
-      VULKAN_HPP_NAMESPACE::Result result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkImportFenceFdKHR(
-          static_cast<VkDevice>( m_device ), reinterpret_cast<const VkImportFenceFdInfoKHR *>( &importFenceFdInfo ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importFenceFdKHR" );
-      }
+      VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements;
+      getDispatcher()->vkGetGeneratedCommandsMemoryRequirementsNV(
+        static_cast<VkDevice>( m_device ),
+        reinterpret_cast<const VkGeneratedCommandsMemoryRequirementsInfoNV *>( &info ),
+        reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
+      return memoryRequirements;
     }
 
-#  if defined( VK_USE_PLATFORM_WIN32_KHR )
-    VULKAN_HPP_INLINE void
-      Device::importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo ) const
+    template <typename X, typename Y, typename... Z>
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getGeneratedCommandsMemoryRequirementsNV(
+      const GeneratedCommandsMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT
     {
       VULKAN_HPP_ASSERT(
-        getDispatcher()->vkImportFenceWin32HandleKHR &&
-        "Function <vkImportFenceWin32HandleKHR> needs extension <VK_KHR_external_fence_win32> enabled!" );
+        getDispatcher()->vkGetGeneratedCommandsMemoryRequirementsNV &&
+        "Function <vkGetGeneratedCommandsMemoryRequirementsNV> needs extension <VK_NV_device_generated_commands> enabled!" );
 
-      VULKAN_HPP_NAMESPACE::Result result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkImportFenceWin32HandleKHR(
-          static_cast<VkDevice>( m_device ),
-          reinterpret_cast<const VkImportFenceWin32HandleInfoKHR *>( &importFenceWin32HandleInfo ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importFenceWin32HandleKHR" );
-      }
-    }
-#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-    VULKAN_HPP_INLINE void Device::importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo ) const
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkImportSemaphoreFdKHR &&
-                         "Function <vkImportSemaphoreFdKHR> needs extension <VK_KHR_external_semaphore_fd> enabled!" );
-
-      VULKAN_HPP_NAMESPACE::Result result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkImportSemaphoreFdKHR(
-          static_cast<VkDevice>( m_device ),
-          reinterpret_cast<const VkImportSemaphoreFdInfoKHR *>( &importSemaphoreFdInfo ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importSemaphoreFdKHR" );
-      }
+      StructureChain<X, Y, Z...>                  structureChain;
+      VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements =
+        structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>();
+      getDispatcher()->vkGetGeneratedCommandsMemoryRequirementsNV(
+        static_cast<VkDevice>( m_device ),
+        reinterpret_cast<const VkGeneratedCommandsMemoryRequirementsInfoNV *>( &info ),
+        reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
+      return structureChain;
     }
 
-#  if defined( VK_USE_PLATFORM_WIN32_KHR )
-    VULKAN_HPP_INLINE void Device::importSemaphoreWin32HandleKHR(
-      const ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo ) const
+    VULKAN_HPP_INLINE void CommandBuffer::preprocessGeneratedCommandsNV(
+      const GeneratedCommandsInfoNV & generatedCommandsInfo ) const VULKAN_HPP_NOEXCEPT
     {
       VULKAN_HPP_ASSERT(
-        getDispatcher()->vkImportSemaphoreWin32HandleKHR &&
-        "Function <vkImportSemaphoreWin32HandleKHR> needs extension <VK_KHR_external_semaphore_win32> enabled!" );
+        getDispatcher()->vkCmdPreprocessGeneratedCommandsNV &&
+        "Function <vkCmdPreprocessGeneratedCommandsNV> needs extension <VK_NV_device_generated_commands> enabled!" );
 
-      VULKAN_HPP_NAMESPACE::Result result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkImportSemaphoreWin32HandleKHR(
-          static_cast<VkDevice>( m_device ),
-          reinterpret_cast<const VkImportSemaphoreWin32HandleInfoKHR *>( &importSemaphoreWin32HandleInfo ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importSemaphoreWin32HandleKHR" );
-      }
+      getDispatcher()->vkCmdPreprocessGeneratedCommandsNV(
+        static_cast<VkCommandBuffer>( m_commandBuffer ),
+        reinterpret_cast<const VkGeneratedCommandsInfoNV *>( &generatedCommandsInfo ) );
     }
-#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
-#  if defined( VK_USE_PLATFORM_FUCHSIA )
-    VULKAN_HPP_INLINE void Device::importSemaphoreZirconHandleFUCHSIA(
-      const ImportSemaphoreZirconHandleInfoFUCHSIA & importSemaphoreZirconHandleInfo ) const
+    VULKAN_HPP_INLINE void CommandBuffer::executeGeneratedCommandsNV(
+      VULKAN_HPP_NAMESPACE::Bool32    isPreprocessed,
+      const GeneratedCommandsInfoNV & generatedCommandsInfo ) const VULKAN_HPP_NOEXCEPT
     {
       VULKAN_HPP_ASSERT(
-        getDispatcher()->vkImportSemaphoreZirconHandleFUCHSIA &&
-        "Function <vkImportSemaphoreZirconHandleFUCHSIA> needs extension <VK_FUCHSIA_external_semaphore> enabled!" );
+        getDispatcher()->vkCmdExecuteGeneratedCommandsNV &&
+        "Function <vkCmdExecuteGeneratedCommandsNV> needs extension <VK_NV_device_generated_commands> enabled!" );
 
-      VULKAN_HPP_NAMESPACE::Result result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkImportSemaphoreZirconHandleFUCHSIA(
-          static_cast<VkDevice>( m_device ),
-          reinterpret_cast<const VkImportSemaphoreZirconHandleInfoFUCHSIA *>( &importSemaphoreZirconHandleInfo ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importSemaphoreZirconHandleFUCHSIA" );
-      }
-    }
-#  endif /*VK_USE_PLATFORM_FUCHSIA*/
-
-    VULKAN_HPP_INLINE void
-      Device::initializePerformanceApiINTEL( const InitializePerformanceApiInfoINTEL & initializeInfo ) const
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkInitializePerformanceApiINTEL &&
-        "Function <vkInitializePerformanceApiINTEL> needs extension <VK_INTEL_performance_query> enabled!" );
-
-      VULKAN_HPP_NAMESPACE::Result result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkInitializePerformanceApiINTEL(
-          static_cast<VkDevice>( m_device ),
-          reinterpret_cast<const VkInitializePerformanceApiInfoINTEL *>( &initializeInfo ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::initializePerformanceApiINTEL" );
-      }
-    }
-
-    VULKAN_HPP_INLINE void Device::invalidateMappedMemoryRanges(
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges ) const
-    {
-      VULKAN_HPP_NAMESPACE::Result result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkInvalidateMappedMemoryRanges(
-          static_cast<VkDevice>( m_device ),
-          memoryRanges.size(),
-          reinterpret_cast<const VkMappedMemoryRange *>( memoryRanges.data() ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::invalidateMappedMemoryRanges" );
-      }
-    }
-
-    VULKAN_HPP_INLINE void Device::releaseProfilingLockKHR() const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkReleaseProfilingLockKHR &&
-                         "Function <vkReleaseProfilingLockKHR> needs extension <VK_KHR_performance_query> enabled!" );
-
-      getDispatcher()->vkReleaseProfilingLockKHR( static_cast<VkDevice>( m_device ) );
-    }
-
-    VULKAN_HPP_INLINE void Device::resetFences( ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences ) const
-    {
-      VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkResetFences(
-        static_cast<VkDevice>( m_device ), fences.size(), reinterpret_cast<const VkFence *>( fences.data() ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::resetFences" );
-      }
-    }
-
-    VULKAN_HPP_INLINE void Device::setDebugUtilsObjectNameEXT( const DebugUtilsObjectNameInfoEXT & nameInfo ) const
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkSetDebugUtilsObjectNameEXT &&
-                         "Function <vkSetDebugUtilsObjectNameEXT> needs extension <VK_EXT_debug_utils> enabled!" );
-
-      VULKAN_HPP_NAMESPACE::Result result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkSetDebugUtilsObjectNameEXT(
-          static_cast<VkDevice>( m_device ), reinterpret_cast<const VkDebugUtilsObjectNameInfoEXT *>( &nameInfo ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setDebugUtilsObjectNameEXT" );
-      }
-    }
-
-    VULKAN_HPP_INLINE void Device::setDebugUtilsObjectTagEXT( const DebugUtilsObjectTagInfoEXT & tagInfo ) const
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkSetDebugUtilsObjectTagEXT &&
-                         "Function <vkSetDebugUtilsObjectTagEXT> needs extension <VK_EXT_debug_utils> enabled!" );
-
-      VULKAN_HPP_NAMESPACE::Result result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkSetDebugUtilsObjectTagEXT(
-          static_cast<VkDevice>( m_device ), reinterpret_cast<const VkDebugUtilsObjectTagInfoEXT *>( &tagInfo ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setDebugUtilsObjectTagEXT" );
-      }
+      getDispatcher()->vkCmdExecuteGeneratedCommandsNV(
+        static_cast<VkCommandBuffer>( m_commandBuffer ),
+        static_cast<VkBool32>( isPreprocessed ),
+        reinterpret_cast<const VkGeneratedCommandsInfoNV *>( &generatedCommandsInfo ) );
     }
 
     VULKAN_HPP_INLINE void
-      Device::setHdrMetadataEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainKHR> const &   swapchains,
-                                 ArrayProxy<const VULKAN_HPP_NAMESPACE::HdrMetadataEXT> const & metadata ) const
-      VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
+      CommandBuffer::bindPipelineShaderGroupNV( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
+                                                VULKAN_HPP_NAMESPACE::Pipeline          pipeline,
+                                                uint32_t groupIndex ) const VULKAN_HPP_NOEXCEPT
     {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkSetHdrMetadataEXT &&
-                         "Function <vkSetHdrMetadataEXT> needs extension <VK_EXT_hdr_metadata> enabled!" );
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkCmdBindPipelineShaderGroupNV &&
+        "Function <vkCmdBindPipelineShaderGroupNV> needs extension <VK_NV_device_generated_commands> enabled!" );
 
-#  ifdef VULKAN_HPP_NO_EXCEPTIONS
-      VULKAN_HPP_ASSERT( swapchains.size() == metadata.size() );
-#  else
-      if ( swapchains.size() != metadata.size() )
-      {
-        throw LogicError( VULKAN_HPP_NAMESPACE_STRING
-                          "::Device::setHdrMetadataEXT: swapchains.size() != metadata.size()" );
-      }
-#  endif /*VULKAN_HPP_NO_EXCEPTIONS*/
-
-      getDispatcher()->vkSetHdrMetadataEXT( static_cast<VkDevice>( m_device ),
-                                            swapchains.size(),
-                                            reinterpret_cast<const VkSwapchainKHR *>( swapchains.data() ),
-                                            reinterpret_cast<const VkHdrMetadataEXT *>( metadata.data() ) );
+      getDispatcher()->vkCmdBindPipelineShaderGroupNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                                       static_cast<VkPipelineBindPoint>( pipelineBindPoint ),
+                                                       static_cast<VkPipeline>( pipeline ),
+                                                       groupIndex );
     }
 
+    //=== VK_EXT_private_data ===
+
     VULKAN_HPP_INLINE void Device::setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType         objectType_,
                                                       uint64_t                                 objectHandle,
                                                       VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot,
@@ -11174,1205 +14503,26 @@ namespace VULKAN_HPP_NAMESPACE
       }
     }
 
-    VULKAN_HPP_INLINE void Device::signalSemaphore( const SemaphoreSignalInfo & signalInfo ) const
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t
+      Device::getPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType         objectType_,
+                                 uint64_t                                 objectHandle,
+                                 VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot ) const VULKAN_HPP_NOEXCEPT
     {
-      VULKAN_HPP_NAMESPACE::Result result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkSignalSemaphore(
-          static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSemaphoreSignalInfo *>( &signalInfo ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::signalSemaphore" );
-      }
-    }
+      VULKAN_HPP_ASSERT( getDispatcher()->vkGetPrivateDataEXT &&
+                         "Function <vkGetPrivateDataEXT> needs extension <VK_EXT_private_data> enabled!" );
 
-    VULKAN_HPP_INLINE void Device::signalSemaphoreKHR( const SemaphoreSignalInfo & signalInfo ) const
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkSignalSemaphoreKHR &&
-                         "Function <vkSignalSemaphoreKHR> needs extension <VK_KHR_timeline_semaphore> enabled!" );
-
-      VULKAN_HPP_NAMESPACE::Result result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkSignalSemaphoreKHR(
-          static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSemaphoreSignalInfo *>( &signalInfo ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::signalSemaphoreKHR" );
-      }
-    }
-
-    VULKAN_HPP_INLINE void Device::uninitializePerformanceApiINTEL() const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkUninitializePerformanceApiINTEL &&
-        "Function <vkUninitializePerformanceApiINTEL> needs extension <VK_INTEL_performance_query> enabled!" );
-
-      getDispatcher()->vkUninitializePerformanceApiINTEL( static_cast<VkDevice>( m_device ) );
-    }
-
-    VULKAN_HPP_INLINE void Device::updateDescriptorSets(
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::CopyDescriptorSet> const &  descriptorCopies ) const VULKAN_HPP_NOEXCEPT
-    {
-      getDispatcher()->vkUpdateDescriptorSets(
-        static_cast<VkDevice>( m_device ),
-        descriptorWrites.size(),
-        reinterpret_cast<const VkWriteDescriptorSet *>( descriptorWrites.data() ),
-        descriptorCopies.size(),
-        reinterpret_cast<const VkCopyDescriptorSet *>( descriptorCopies.data() ) );
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result
-      Device::waitForFences( ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences,
-                             VULKAN_HPP_NAMESPACE::Bool32                          waitAll,
-                             uint64_t                                              timeout ) const
-    {
-      VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-        getDispatcher()->vkWaitForFences( static_cast<VkDevice>( m_device ),
-                                          fences.size(),
-                                          reinterpret_cast<const VkFence *>( fences.data() ),
-                                          static_cast<VkBool32>( waitAll ),
-                                          timeout ) );
-      if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) &&
-           ( result != VULKAN_HPP_NAMESPACE::Result::eTimeout ) )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::waitForFences" );
-      }
-      return result;
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result
-      Device::waitSemaphores( const SemaphoreWaitInfo & waitInfo, uint64_t timeout ) const
-    {
-      VULKAN_HPP_NAMESPACE::Result result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkWaitSemaphores(
-          static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSemaphoreWaitInfo *>( &waitInfo ), timeout ) );
-      if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) &&
-           ( result != VULKAN_HPP_NAMESPACE::Result::eTimeout ) )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::waitSemaphores" );
-      }
-      return result;
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result
-      Device::waitSemaphoresKHR( const SemaphoreWaitInfo & waitInfo, uint64_t timeout ) const
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkWaitSemaphoresKHR &&
-                         "Function <vkWaitSemaphoresKHR> needs extension <VK_KHR_timeline_semaphore> enabled!" );
-
-      VULKAN_HPP_NAMESPACE::Result result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkWaitSemaphoresKHR(
-          static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSemaphoreWaitInfo *>( &waitInfo ), timeout ) );
-      if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) &&
-           ( result != VULKAN_HPP_NAMESPACE::Result::eTimeout ) )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::waitSemaphoresKHR" );
-      }
-      return result;
-    }
-
-    template <typename T>
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<T> Device::writeAccelerationStructuresPropertiesKHR(
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
-      VULKAN_HPP_NAMESPACE::QueryType                                          queryType,
-      size_t                                                                   dataSize,
-      size_t                                                                   stride ) const
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkWriteAccelerationStructuresPropertiesKHR &&
-        "Function <vkWriteAccelerationStructuresPropertiesKHR> needs extension <VK_KHR_acceleration_structure> enabled!" );
-
-      VULKAN_HPP_ASSERT( dataSize % sizeof( T ) == 0 );
-      std::vector<T> data( dataSize / sizeof( T ) );
-      Result         result = static_cast<Result>( getDispatcher()->vkWriteAccelerationStructuresPropertiesKHR(
-        static_cast<VkDevice>( m_device ),
-        accelerationStructures.size(),
-        reinterpret_cast<const VkAccelerationStructureKHR *>( accelerationStructures.data() ),
-        static_cast<VkQueryType>( queryType ),
-        data.size() * sizeof( T ),
-        reinterpret_cast<void *>( data.data() ),
-        stride ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result,
-                              VULKAN_HPP_NAMESPACE_STRING "::Device::writeAccelerationStructuresPropertiesKHR" );
-      }
+      uint64_t data;
+      getDispatcher()->vkGetPrivateDataEXT( static_cast<VkDevice>( m_device ),
+                                            static_cast<VkObjectType>( objectType_ ),
+                                            objectHandle,
+                                            static_cast<VkPrivateDataSlotEXT>( privateDataSlot ),
+                                            &data );
       return data;
     }
 
-    template <typename T>
-    VULKAN_HPP_NODISCARD T Device::writeAccelerationStructuresPropertyKHR(
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
-      VULKAN_HPP_NAMESPACE::QueryType                                          queryType,
-      size_t                                                                   stride ) const
-    {
-      T      data;
-      Result result = static_cast<Result>( getDispatcher()->vkWriteAccelerationStructuresPropertiesKHR(
-        static_cast<VkDevice>( m_device ),
-        accelerationStructures.size(),
-        reinterpret_cast<const VkAccelerationStructureKHR *>( accelerationStructures.data() ),
-        static_cast<VkQueryType>( queryType ),
-        sizeof( T ),
-        reinterpret_cast<void *>( &data ),
-        stride ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::writeAccelerationStructuresPropertyKHR" );
-      }
-      return data;
-    }
-
-    template <typename T>
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<T> AccelerationStructureNV::getHandle( size_t dataSize ) const
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkGetAccelerationStructureHandleNV &&
-                         "Function <vkGetAccelerationStructureHandleNV> needs extension <VK_NV_ray_tracing> enabled!" );
-
-      VULKAN_HPP_ASSERT( dataSize % sizeof( T ) == 0 );
-      std::vector<T> data( dataSize / sizeof( T ) );
-      Result         result = static_cast<Result>( getDispatcher()->vkGetAccelerationStructureHandleNV(
-        static_cast<VkDevice>( m_device ),
-        static_cast<VkAccelerationStructureNV>( m_accelerationStructureNV ),
-        data.size() * sizeof( T ),
-        reinterpret_cast<void *>( data.data() ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::AccelerationStructureNV::getHandle" );
-      }
-      return data;
-    }
-
-    template <typename T>
-    VULKAN_HPP_NODISCARD T AccelerationStructureNV::getHandle() const
-    {
-      T      data;
-      Result result = static_cast<Result>( getDispatcher()->vkGetAccelerationStructureHandleNV(
-        static_cast<VkDevice>( m_device ),
-        static_cast<VkAccelerationStructureNV>( m_accelerationStructureNV ),
-        sizeof( T ),
-        reinterpret_cast<void *>( &data ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::AccelerationStructureNV::getHandle" );
-      }
-      return data;
-    }
-
-    VULKAN_HPP_INLINE void Buffer::bindMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory,
-                                               VULKAN_HPP_NAMESPACE::DeviceSize   memoryOffset ) const
-    {
-      VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-        getDispatcher()->vkBindBufferMemory( static_cast<VkDevice>( m_device ),
-                                             static_cast<VkBuffer>( m_buffer ),
-                                             static_cast<VkDeviceMemory>( memory ),
-                                             static_cast<VkDeviceSize>( memoryOffset ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Buffer::bindMemory" );
-      }
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements
-                                           Buffer::getMemoryRequirements() const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_NAMESPACE::MemoryRequirements memoryRequirements;
-      getDispatcher()->vkGetBufferMemoryRequirements( static_cast<VkDevice>( m_device ),
-                                                      static_cast<VkBuffer>( m_buffer ),
-                                                      reinterpret_cast<VkMemoryRequirements *>( &memoryRequirements ) );
-      return memoryRequirements;
-    }
-
-    VULKAN_HPP_INLINE void CommandPool::reset( VULKAN_HPP_NAMESPACE::CommandPoolResetFlags flags ) const
-    {
-      VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-        getDispatcher()->vkResetCommandPool( static_cast<VkDevice>( m_device ),
-                                             static_cast<VkCommandPool>( m_commandPool ),
-                                             static_cast<VkCommandPoolResetFlags>( flags ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::CommandPool::reset" );
-      }
-    }
-
-    VULKAN_HPP_INLINE void
-      CommandPool::trim( VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags ) const VULKAN_HPP_NOEXCEPT
-    {
-      getDispatcher()->vkTrimCommandPool( static_cast<VkDevice>( m_device ),
-                                          static_cast<VkCommandPool>( m_commandPool ),
-                                          static_cast<VkCommandPoolTrimFlags>( flags ) );
-    }
-
-    VULKAN_HPP_INLINE void
-      CommandPool::trimKHR( VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkTrimCommandPoolKHR &&
-                         "Function <vkTrimCommandPoolKHR> needs extension <VK_KHR_maintenance1> enabled!" );
-
-      getDispatcher()->vkTrimCommandPoolKHR( static_cast<VkDevice>( m_device ),
-                                             static_cast<VkCommandPool>( m_commandPool ),
-                                             static_cast<VkCommandPoolTrimFlags>( flags ) );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::begin( const CommandBufferBeginInfo & beginInfo ) const
-    {
-      VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-        getDispatcher()->vkBeginCommandBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                               reinterpret_cast<const VkCommandBufferBeginInfo *>( &beginInfo ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::begin" );
-      }
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::beginConditionalRenderingEXT(
-      const ConditionalRenderingBeginInfoEXT & conditionalRenderingBegin ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkCmdBeginConditionalRenderingEXT &&
-        "Function <vkCmdBeginConditionalRenderingEXT> needs extension <VK_EXT_conditional_rendering> enabled!" );
-
-      getDispatcher()->vkCmdBeginConditionalRenderingEXT(
-        static_cast<VkCommandBuffer>( m_commandBuffer ),
-        reinterpret_cast<const VkConditionalRenderingBeginInfoEXT *>( &conditionalRenderingBegin ) );
-    }
-
-    VULKAN_HPP_INLINE void
-      CommandBuffer::beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginDebugUtilsLabelEXT &&
-                         "Function <vkCmdBeginDebugUtilsLabelEXT> needs extension <VK_EXT_debug_utils> enabled!" );
-
-      getDispatcher()->vkCmdBeginDebugUtilsLabelEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                                     reinterpret_cast<const VkDebugUtilsLabelEXT *>( &labelInfo ) );
-    }
-
-    VULKAN_HPP_INLINE void
-      CommandBuffer::beginQuery( VULKAN_HPP_NAMESPACE::QueryPool         queryPool,
-                                 uint32_t                                query,
-                                 VULKAN_HPP_NAMESPACE::QueryControlFlags flags ) const VULKAN_HPP_NOEXCEPT
-    {
-      getDispatcher()->vkCmdBeginQuery( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                        static_cast<VkQueryPool>( queryPool ),
-                                        query,
-                                        static_cast<VkQueryControlFlags>( flags ) );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::beginQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool         queryPool,
-                                                                uint32_t                                query,
-                                                                VULKAN_HPP_NAMESPACE::QueryControlFlags flags,
-                                                                uint32_t index ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginQueryIndexedEXT &&
-                         "Function <vkCmdBeginQueryIndexedEXT> needs extension <VK_EXT_transform_feedback> enabled!" );
-
-      getDispatcher()->vkCmdBeginQueryIndexedEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                                  static_cast<VkQueryPool>( queryPool ),
-                                                  query,
-                                                  static_cast<VkQueryControlFlags>( flags ),
-                                                  index );
-    }
-
-    VULKAN_HPP_INLINE void
-      CommandBuffer::beginRenderPass( const RenderPassBeginInfo &           renderPassBegin,
-                                      VULKAN_HPP_NAMESPACE::SubpassContents contents ) const VULKAN_HPP_NOEXCEPT
-    {
-      getDispatcher()->vkCmdBeginRenderPass( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                             reinterpret_cast<const VkRenderPassBeginInfo *>( &renderPassBegin ),
-                                             static_cast<VkSubpassContents>( contents ) );
-    }
-
-    VULKAN_HPP_INLINE void
-      CommandBuffer::beginRenderPass2( const RenderPassBeginInfo & renderPassBegin,
-                                       const SubpassBeginInfo &    subpassBeginInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      getDispatcher()->vkCmdBeginRenderPass2( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                              reinterpret_cast<const VkRenderPassBeginInfo *>( &renderPassBegin ),
-                                              reinterpret_cast<const VkSubpassBeginInfo *>( &subpassBeginInfo ) );
-    }
-
-    VULKAN_HPP_INLINE void
-      CommandBuffer::beginRenderPass2KHR( const RenderPassBeginInfo & renderPassBegin,
-                                          const SubpassBeginInfo &    subpassBeginInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginRenderPass2KHR &&
-                         "Function <vkCmdBeginRenderPass2KHR> needs extension <VK_KHR_create_renderpass2> enabled!" );
-
-      getDispatcher()->vkCmdBeginRenderPass2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                                 reinterpret_cast<const VkRenderPassBeginInfo *>( &renderPassBegin ),
-                                                 reinterpret_cast<const VkSubpassBeginInfo *>( &subpassBeginInfo ) );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::beginTransformFeedbackEXT(
-      uint32_t                                                   firstCounterBuffer,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &     counterBuffers,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets ) const
-      VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkCmdBeginTransformFeedbackEXT &&
-        "Function <vkCmdBeginTransformFeedbackEXT> needs extension <VK_EXT_transform_feedback> enabled!" );
-
-#  ifdef VULKAN_HPP_NO_EXCEPTIONS
-      VULKAN_HPP_ASSERT( counterBufferOffsets.empty() || counterBuffers.size() == counterBufferOffsets.size() );
-#  else
-      if ( !counterBufferOffsets.empty() && counterBuffers.size() != counterBufferOffsets.size() )
-      {
-        throw LogicError(
-          VULKAN_HPP_NAMESPACE_STRING
-          "::CommandBuffer::beginTransformFeedbackEXT: counterBuffers.size() != counterBufferOffsets.size()" );
-      }
-#  endif /*VULKAN_HPP_NO_EXCEPTIONS*/
-
-      getDispatcher()->vkCmdBeginTransformFeedbackEXT(
-        static_cast<VkCommandBuffer>( m_commandBuffer ),
-        firstCounterBuffer,
-        counterBuffers.size(),
-        reinterpret_cast<const VkBuffer *>( counterBuffers.data() ),
-        reinterpret_cast<const VkDeviceSize *>( counterBufferOffsets.data() ) );
-    }
-
 #  if defined( VK_ENABLE_BETA_EXTENSIONS )
-    VULKAN_HPP_INLINE void
-      CommandBuffer::beginVideoCodingKHR( const VideoBeginCodingInfoKHR & beginInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginVideoCodingKHR &&
-                         "Function <vkCmdBeginVideoCodingKHR> needs extension <VK_KHR_video_queue> enabled!" );
+    //=== VK_KHR_video_encode_queue ===
 
-      getDispatcher()->vkCmdBeginVideoCodingKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                                 reinterpret_cast<const VkVideoBeginCodingInfoKHR *>( &beginInfo ) );
-    }
-#  endif /*VK_ENABLE_BETA_EXTENSIONS*/
-
-    VULKAN_HPP_INLINE void
-      CommandBuffer::bindDescriptorSets( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
-                                         VULKAN_HPP_NAMESPACE::PipelineLayout    layout,
-                                         uint32_t                                firstSet,
-                                         ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets,
-                                         ArrayProxy<const uint32_t> const & dynamicOffsets ) const VULKAN_HPP_NOEXCEPT
-    {
-      getDispatcher()->vkCmdBindDescriptorSets( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                                static_cast<VkPipelineBindPoint>( pipelineBindPoint ),
-                                                static_cast<VkPipelineLayout>( layout ),
-                                                firstSet,
-                                                descriptorSets.size(),
-                                                reinterpret_cast<const VkDescriptorSet *>( descriptorSets.data() ),
-                                                dynamicOffsets.size(),
-                                                dynamicOffsets.data() );
-    }
-
-    VULKAN_HPP_INLINE void
-      CommandBuffer::bindIndexBuffer( VULKAN_HPP_NAMESPACE::Buffer     buffer,
-                                      VULKAN_HPP_NAMESPACE::DeviceSize offset,
-                                      VULKAN_HPP_NAMESPACE::IndexType  indexType ) const VULKAN_HPP_NOEXCEPT
-    {
-      getDispatcher()->vkCmdBindIndexBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                             static_cast<VkBuffer>( buffer ),
-                                             static_cast<VkDeviceSize>( offset ),
-                                             static_cast<VkIndexType>( indexType ) );
-    }
-
-    VULKAN_HPP_INLINE void
-      CommandBuffer::bindPipeline( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
-                                   VULKAN_HPP_NAMESPACE::Pipeline          pipeline ) const VULKAN_HPP_NOEXCEPT
-    {
-      getDispatcher()->vkCmdBindPipeline( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                          static_cast<VkPipelineBindPoint>( pipelineBindPoint ),
-                                          static_cast<VkPipeline>( pipeline ) );
-    }
-
-    VULKAN_HPP_INLINE void
-      CommandBuffer::bindPipelineShaderGroupNV( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
-                                                VULKAN_HPP_NAMESPACE::Pipeline          pipeline,
-                                                uint32_t groupIndex ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkCmdBindPipelineShaderGroupNV &&
-        "Function <vkCmdBindPipelineShaderGroupNV> needs extension <VK_NV_device_generated_commands> enabled!" );
-
-      getDispatcher()->vkCmdBindPipelineShaderGroupNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                                       static_cast<VkPipelineBindPoint>( pipelineBindPoint ),
-                                                       static_cast<VkPipeline>( pipeline ),
-                                                       groupIndex );
-    }
-
-    VULKAN_HPP_INLINE void
-      CommandBuffer::bindShadingRateImageNV( VULKAN_HPP_NAMESPACE::ImageView   imageView,
-                                             VULKAN_HPP_NAMESPACE::ImageLayout imageLayout ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindShadingRateImageNV &&
-                         "Function <vkCmdBindShadingRateImageNV> needs extension <VK_NV_shading_rate_image> enabled!" );
-
-      getDispatcher()->vkCmdBindShadingRateImageNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                                    static_cast<VkImageView>( imageView ),
-                                                    static_cast<VkImageLayout>( imageLayout ) );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::bindTransformFeedbackBuffersEXT(
-      uint32_t                                                   firstBinding,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &     buffers,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkCmdBindTransformFeedbackBuffersEXT &&
-        "Function <vkCmdBindTransformFeedbackBuffersEXT> needs extension <VK_EXT_transform_feedback> enabled!" );
-
-#  ifdef VULKAN_HPP_NO_EXCEPTIONS
-      VULKAN_HPP_ASSERT( buffers.size() == offsets.size() );
-      VULKAN_HPP_ASSERT( sizes.empty() || buffers.size() == sizes.size() );
-#  else
-      if ( buffers.size() != offsets.size() )
-      {
-        throw LogicError( VULKAN_HPP_NAMESPACE_STRING
-                          "::CommandBuffer::bindTransformFeedbackBuffersEXT: buffers.size() != offsets.size()" );
-      }
-      if ( !sizes.empty() && buffers.size() != sizes.size() )
-      {
-        throw LogicError( VULKAN_HPP_NAMESPACE_STRING
-                          "::CommandBuffer::bindTransformFeedbackBuffersEXT: buffers.size() != sizes.size()" );
-      }
-#  endif /*VULKAN_HPP_NO_EXCEPTIONS*/
-
-      getDispatcher()->vkCmdBindTransformFeedbackBuffersEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                                             firstBinding,
-                                                             buffers.size(),
-                                                             reinterpret_cast<const VkBuffer *>( buffers.data() ),
-                                                             reinterpret_cast<const VkDeviceSize *>( offsets.data() ),
-                                                             reinterpret_cast<const VkDeviceSize *>( sizes.data() ) );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers(
-      uint32_t                                                   firstBinding,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &     buffers,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
-    {
-#  ifdef VULKAN_HPP_NO_EXCEPTIONS
-      VULKAN_HPP_ASSERT( buffers.size() == offsets.size() );
-#  else
-      if ( buffers.size() != offsets.size() )
-      {
-        throw LogicError( VULKAN_HPP_NAMESPACE_STRING
-                          "::CommandBuffer::bindVertexBuffers: buffers.size() != offsets.size()" );
-      }
-#  endif /*VULKAN_HPP_NO_EXCEPTIONS*/
-
-      getDispatcher()->vkCmdBindVertexBuffers( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                               firstBinding,
-                                               buffers.size(),
-                                               reinterpret_cast<const VkBuffer *>( buffers.data() ),
-                                               reinterpret_cast<const VkDeviceSize *>( offsets.data() ) );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers2EXT(
-      uint32_t                                                   firstBinding,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &     buffers,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & strides ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkCmdBindVertexBuffers2EXT &&
-        "Function <vkCmdBindVertexBuffers2EXT> needs extension <VK_EXT_extended_dynamic_state> enabled!" );
-
-#  ifdef VULKAN_HPP_NO_EXCEPTIONS
-      VULKAN_HPP_ASSERT( buffers.size() == offsets.size() );
-      VULKAN_HPP_ASSERT( sizes.empty() || buffers.size() == sizes.size() );
-      VULKAN_HPP_ASSERT( strides.empty() || buffers.size() == strides.size() );
-#  else
-      if ( buffers.size() != offsets.size() )
-      {
-        throw LogicError( VULKAN_HPP_NAMESPACE_STRING
-                          "::CommandBuffer::bindVertexBuffers2EXT: buffers.size() != offsets.size()" );
-      }
-      if ( !sizes.empty() && buffers.size() != sizes.size() )
-      {
-        throw LogicError( VULKAN_HPP_NAMESPACE_STRING
-                          "::CommandBuffer::bindVertexBuffers2EXT: buffers.size() != sizes.size()" );
-      }
-      if ( !strides.empty() && buffers.size() != strides.size() )
-      {
-        throw LogicError( VULKAN_HPP_NAMESPACE_STRING
-                          "::CommandBuffer::bindVertexBuffers2EXT: buffers.size() != strides.size()" );
-      }
-#  endif /*VULKAN_HPP_NO_EXCEPTIONS*/
-
-      getDispatcher()->vkCmdBindVertexBuffers2EXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                                   firstBinding,
-                                                   buffers.size(),
-                                                   reinterpret_cast<const VkBuffer *>( buffers.data() ),
-                                                   reinterpret_cast<const VkDeviceSize *>( offsets.data() ),
-                                                   reinterpret_cast<const VkDeviceSize *>( sizes.data() ),
-                                                   reinterpret_cast<const VkDeviceSize *>( strides.data() ) );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::blitImage( VULKAN_HPP_NAMESPACE::Image       srcImage,
-                                                     VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout,
-                                                     VULKAN_HPP_NAMESPACE::Image       dstImage,
-                                                     VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,
-                                                     ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageBlit> const & regions,
-                                                     VULKAN_HPP_NAMESPACE::Filter filter ) const VULKAN_HPP_NOEXCEPT
-    {
-      getDispatcher()->vkCmdBlitImage( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                       static_cast<VkImage>( srcImage ),
-                                       static_cast<VkImageLayout>( srcImageLayout ),
-                                       static_cast<VkImage>( dstImage ),
-                                       static_cast<VkImageLayout>( dstImageLayout ),
-                                       regions.size(),
-                                       reinterpret_cast<const VkImageBlit *>( regions.data() ),
-                                       static_cast<VkFilter>( filter ) );
-    }
-
-    VULKAN_HPP_INLINE void
-      CommandBuffer::blitImage2KHR( const BlitImageInfo2KHR & blitImageInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBlitImage2KHR &&
-                         "Function <vkCmdBlitImage2KHR> needs extension <VK_KHR_copy_commands2> enabled!" );
-
-      getDispatcher()->vkCmdBlitImage2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                           reinterpret_cast<const VkBlitImageInfo2KHR *>( &blitImageInfo ) );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructureNV(
-      const AccelerationStructureInfoNV &           info,
-      VULKAN_HPP_NAMESPACE::Buffer                  instanceData,
-      VULKAN_HPP_NAMESPACE::DeviceSize              instanceOffset,
-      VULKAN_HPP_NAMESPACE::Bool32                  update,
-      VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst,
-      VULKAN_HPP_NAMESPACE::AccelerationStructureNV src,
-      VULKAN_HPP_NAMESPACE::Buffer                  scratch,
-      VULKAN_HPP_NAMESPACE::DeviceSize              scratchOffset ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBuildAccelerationStructureNV &&
-                         "Function <vkCmdBuildAccelerationStructureNV> needs extension <VK_NV_ray_tracing> enabled!" );
-
-      getDispatcher()->vkCmdBuildAccelerationStructureNV(
-        static_cast<VkCommandBuffer>( m_commandBuffer ),
-        reinterpret_cast<const VkAccelerationStructureInfoNV *>( &info ),
-        static_cast<VkBuffer>( instanceData ),
-        static_cast<VkDeviceSize>( instanceOffset ),
-        static_cast<VkBool32>( update ),
-        static_cast<VkAccelerationStructureNV>( dst ),
-        static_cast<VkAccelerationStructureNV>( src ),
-        static_cast<VkBuffer>( scratch ),
-        static_cast<VkDeviceSize>( scratchOffset ) );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructuresIndirectKHR(
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceAddress> const &                             indirectDeviceAddresses,
-      ArrayProxy<const uint32_t> const &                                                        indirectStrides,
-      ArrayProxy<const uint32_t * const> const & pMaxPrimitiveCounts ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkCmdBuildAccelerationStructuresIndirectKHR &&
-        "Function <vkCmdBuildAccelerationStructuresIndirectKHR> needs extension <VK_KHR_acceleration_structure> enabled!" );
-
-#  ifdef VULKAN_HPP_NO_EXCEPTIONS
-      VULKAN_HPP_ASSERT( infos.size() == indirectDeviceAddresses.size() );
-      VULKAN_HPP_ASSERT( infos.size() == indirectStrides.size() );
-      VULKAN_HPP_ASSERT( infos.size() == pMaxPrimitiveCounts.size() );
-#  else
-      if ( infos.size() != indirectDeviceAddresses.size() )
-      {
-        throw LogicError(
-          VULKAN_HPP_NAMESPACE_STRING
-          "::CommandBuffer::buildAccelerationStructuresIndirectKHR: infos.size() != indirectDeviceAddresses.size()" );
-      }
-      if ( infos.size() != indirectStrides.size() )
-      {
-        throw LogicError(
-          VULKAN_HPP_NAMESPACE_STRING
-          "::CommandBuffer::buildAccelerationStructuresIndirectKHR: infos.size() != indirectStrides.size()" );
-      }
-      if ( infos.size() != pMaxPrimitiveCounts.size() )
-      {
-        throw LogicError(
-          VULKAN_HPP_NAMESPACE_STRING
-          "::CommandBuffer::buildAccelerationStructuresIndirectKHR: infos.size() != pMaxPrimitiveCounts.size()" );
-      }
-#  endif /*VULKAN_HPP_NO_EXCEPTIONS*/
-
-      getDispatcher()->vkCmdBuildAccelerationStructuresIndirectKHR(
-        static_cast<VkCommandBuffer>( m_commandBuffer ),
-        infos.size(),
-        reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( infos.data() ),
-        reinterpret_cast<const VkDeviceAddress *>( indirectDeviceAddresses.data() ),
-        indirectStrides.data(),
-        pMaxPrimitiveCounts.data() );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructuresKHR(
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const &      infos,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos )
-      const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkCmdBuildAccelerationStructuresKHR &&
-        "Function <vkCmdBuildAccelerationStructuresKHR> needs extension <VK_KHR_acceleration_structure> enabled!" );
-
-#  ifdef VULKAN_HPP_NO_EXCEPTIONS
-      VULKAN_HPP_ASSERT( infos.size() == pBuildRangeInfos.size() );
-#  else
-      if ( infos.size() != pBuildRangeInfos.size() )
-      {
-        throw LogicError( VULKAN_HPP_NAMESPACE_STRING
-                          "::CommandBuffer::buildAccelerationStructuresKHR: infos.size() != pBuildRangeInfos.size()" );
-      }
-#  endif /*VULKAN_HPP_NO_EXCEPTIONS*/
-
-      getDispatcher()->vkCmdBuildAccelerationStructuresKHR(
-        static_cast<VkCommandBuffer>( m_commandBuffer ),
-        infos.size(),
-        reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( infos.data() ),
-        reinterpret_cast<const VkAccelerationStructureBuildRangeInfoKHR * const *>( pBuildRangeInfos.data() ) );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::clearAttachments(
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearAttachment> const & attachments,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearRect> const &       rects ) const VULKAN_HPP_NOEXCEPT
-    {
-      getDispatcher()->vkCmdClearAttachments( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                              attachments.size(),
-                                              reinterpret_cast<const VkClearAttachment *>( attachments.data() ),
-                                              rects.size(),
-                                              reinterpret_cast<const VkClearRect *>( rects.data() ) );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::clearColorImage(
-      VULKAN_HPP_NAMESPACE::Image                                           image,
-      VULKAN_HPP_NAMESPACE::ImageLayout                                     imageLayout,
-      const ClearColorValue &                                               color,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceRange> const & ranges ) const VULKAN_HPP_NOEXCEPT
-    {
-      getDispatcher()->vkCmdClearColorImage( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                             static_cast<VkImage>( image ),
-                                             static_cast<VkImageLayout>( imageLayout ),
-                                             reinterpret_cast<const VkClearColorValue *>( &color ),
-                                             ranges.size(),
-                                             reinterpret_cast<const VkImageSubresourceRange *>( ranges.data() ) );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::clearDepthStencilImage(
-      VULKAN_HPP_NAMESPACE::Image                                           image,
-      VULKAN_HPP_NAMESPACE::ImageLayout                                     imageLayout,
-      const ClearDepthStencilValue &                                        depthStencil,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceRange> const & ranges ) const VULKAN_HPP_NOEXCEPT
-    {
-      getDispatcher()->vkCmdClearDepthStencilImage(
-        static_cast<VkCommandBuffer>( m_commandBuffer ),
-        static_cast<VkImage>( image ),
-        static_cast<VkImageLayout>( imageLayout ),
-        reinterpret_cast<const VkClearDepthStencilValue *>( &depthStencil ),
-        ranges.size(),
-        reinterpret_cast<const VkImageSubresourceRange *>( ranges.data() ) );
-    }
-
-#  if defined( VK_ENABLE_BETA_EXTENSIONS )
-    VULKAN_HPP_INLINE void CommandBuffer::controlVideoCodingKHR(
-      const VideoCodingControlInfoKHR & codingControlInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdControlVideoCodingKHR &&
-                         "Function <vkCmdControlVideoCodingKHR> needs extension <VK_KHR_video_queue> enabled!" );
-
-      getDispatcher()->vkCmdControlVideoCodingKHR(
-        static_cast<VkCommandBuffer>( m_commandBuffer ),
-        reinterpret_cast<const VkVideoCodingControlInfoKHR *>( &codingControlInfo ) );
-    }
-#  endif /*VK_ENABLE_BETA_EXTENSIONS*/
-
-    VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureKHR(
-      const CopyAccelerationStructureInfoKHR & info ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkCmdCopyAccelerationStructureKHR &&
-        "Function <vkCmdCopyAccelerationStructureKHR> needs extension <VK_KHR_acceleration_structure> enabled!" );
-
-      getDispatcher()->vkCmdCopyAccelerationStructureKHR(
-        static_cast<VkCommandBuffer>( m_commandBuffer ),
-        reinterpret_cast<const VkCopyAccelerationStructureInfoKHR *>( &info ) );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureNV(
-      VULKAN_HPP_NAMESPACE::AccelerationStructureNV          dst,
-      VULKAN_HPP_NAMESPACE::AccelerationStructureNV          src,
-      VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR mode ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyAccelerationStructureNV &&
-                         "Function <vkCmdCopyAccelerationStructureNV> needs extension <VK_NV_ray_tracing> enabled!" );
-
-      getDispatcher()->vkCmdCopyAccelerationStructureNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                                         static_cast<VkAccelerationStructureNV>( dst ),
-                                                         static_cast<VkAccelerationStructureNV>( src ),
-                                                         static_cast<VkCopyAccelerationStructureModeKHR>( mode ) );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureToMemoryKHR(
-      const CopyAccelerationStructureToMemoryInfoKHR & info ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkCmdCopyAccelerationStructureToMemoryKHR &&
-        "Function <vkCmdCopyAccelerationStructureToMemoryKHR> needs extension <VK_KHR_acceleration_structure> enabled!" );
-
-      getDispatcher()->vkCmdCopyAccelerationStructureToMemoryKHR(
-        static_cast<VkCommandBuffer>( m_commandBuffer ),
-        reinterpret_cast<const VkCopyAccelerationStructureToMemoryInfoKHR *>( &info ) );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::copyBuffer(
-      VULKAN_HPP_NAMESPACE::Buffer                               srcBuffer,
-      VULKAN_HPP_NAMESPACE::Buffer                               dstBuffer,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferCopy> const & regions ) const VULKAN_HPP_NOEXCEPT
-    {
-      getDispatcher()->vkCmdCopyBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                        static_cast<VkBuffer>( srcBuffer ),
-                                        static_cast<VkBuffer>( dstBuffer ),
-                                        regions.size(),
-                                        reinterpret_cast<const VkBufferCopy *>( regions.data() ) );
-    }
-
-    VULKAN_HPP_INLINE void
-      CommandBuffer::copyBuffer2KHR( const CopyBufferInfo2KHR & copyBufferInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyBuffer2KHR &&
-                         "Function <vkCmdCopyBuffer2KHR> needs extension <VK_KHR_copy_commands2> enabled!" );
-
-      getDispatcher()->vkCmdCopyBuffer2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                            reinterpret_cast<const VkCopyBufferInfo2KHR *>( &copyBufferInfo ) );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage(
-      VULKAN_HPP_NAMESPACE::Buffer                                    srcBuffer,
-      VULKAN_HPP_NAMESPACE::Image                                     dstImage,
-      VULKAN_HPP_NAMESPACE::ImageLayout                               dstImageLayout,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions ) const VULKAN_HPP_NOEXCEPT
-    {
-      getDispatcher()->vkCmdCopyBufferToImage( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                               static_cast<VkBuffer>( srcBuffer ),
-                                               static_cast<VkImage>( dstImage ),
-                                               static_cast<VkImageLayout>( dstImageLayout ),
-                                               regions.size(),
-                                               reinterpret_cast<const VkBufferImageCopy *>( regions.data() ) );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage2KHR(
-      const CopyBufferToImageInfo2KHR & copyBufferToImageInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyBufferToImage2KHR &&
-                         "Function <vkCmdCopyBufferToImage2KHR> needs extension <VK_KHR_copy_commands2> enabled!" );
-
-      getDispatcher()->vkCmdCopyBufferToImage2KHR(
-        static_cast<VkCommandBuffer>( m_commandBuffer ),
-        reinterpret_cast<const VkCopyBufferToImageInfo2KHR *>( &copyBufferToImageInfo ) );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::copyImage(
-      VULKAN_HPP_NAMESPACE::Image                               srcImage,
-      VULKAN_HPP_NAMESPACE::ImageLayout                         srcImageLayout,
-      VULKAN_HPP_NAMESPACE::Image                               dstImage,
-      VULKAN_HPP_NAMESPACE::ImageLayout                         dstImageLayout,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageCopy> const & regions ) const VULKAN_HPP_NOEXCEPT
-    {
-      getDispatcher()->vkCmdCopyImage( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                       static_cast<VkImage>( srcImage ),
-                                       static_cast<VkImageLayout>( srcImageLayout ),
-                                       static_cast<VkImage>( dstImage ),
-                                       static_cast<VkImageLayout>( dstImageLayout ),
-                                       regions.size(),
-                                       reinterpret_cast<const VkImageCopy *>( regions.data() ) );
-    }
-
-    VULKAN_HPP_INLINE void
-      CommandBuffer::copyImage2KHR( const CopyImageInfo2KHR & copyImageInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyImage2KHR &&
-                         "Function <vkCmdCopyImage2KHR> needs extension <VK_KHR_copy_commands2> enabled!" );
-
-      getDispatcher()->vkCmdCopyImage2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                           reinterpret_cast<const VkCopyImageInfo2KHR *>( &copyImageInfo ) );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer(
-      VULKAN_HPP_NAMESPACE::Image                                     srcImage,
-      VULKAN_HPP_NAMESPACE::ImageLayout                               srcImageLayout,
-      VULKAN_HPP_NAMESPACE::Buffer                                    dstBuffer,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions ) const VULKAN_HPP_NOEXCEPT
-    {
-      getDispatcher()->vkCmdCopyImageToBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                               static_cast<VkImage>( srcImage ),
-                                               static_cast<VkImageLayout>( srcImageLayout ),
-                                               static_cast<VkBuffer>( dstBuffer ),
-                                               regions.size(),
-                                               reinterpret_cast<const VkBufferImageCopy *>( regions.data() ) );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer2KHR(
-      const CopyImageToBufferInfo2KHR & copyImageToBufferInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyImageToBuffer2KHR &&
-                         "Function <vkCmdCopyImageToBuffer2KHR> needs extension <VK_KHR_copy_commands2> enabled!" );
-
-      getDispatcher()->vkCmdCopyImageToBuffer2KHR(
-        static_cast<VkCommandBuffer>( m_commandBuffer ),
-        reinterpret_cast<const VkCopyImageToBufferInfo2KHR *>( &copyImageToBufferInfo ) );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::copyMemoryToAccelerationStructureKHR(
-      const CopyMemoryToAccelerationStructureInfoKHR & info ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkCmdCopyMemoryToAccelerationStructureKHR &&
-        "Function <vkCmdCopyMemoryToAccelerationStructureKHR> needs extension <VK_KHR_acceleration_structure> enabled!" );
-
-      getDispatcher()->vkCmdCopyMemoryToAccelerationStructureKHR(
-        static_cast<VkCommandBuffer>( m_commandBuffer ),
-        reinterpret_cast<const VkCopyMemoryToAccelerationStructureInfoKHR *>( &info ) );
-    }
-
-    VULKAN_HPP_INLINE void
-      CommandBuffer::copyQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool        queryPool,
-                                           uint32_t                               firstQuery,
-                                           uint32_t                               queryCount,
-                                           VULKAN_HPP_NAMESPACE::Buffer           dstBuffer,
-                                           VULKAN_HPP_NAMESPACE::DeviceSize       dstOffset,
-                                           VULKAN_HPP_NAMESPACE::DeviceSize       stride,
-                                           VULKAN_HPP_NAMESPACE::QueryResultFlags flags ) const VULKAN_HPP_NOEXCEPT
-    {
-      getDispatcher()->vkCmdCopyQueryPoolResults( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                                  static_cast<VkQueryPool>( queryPool ),
-                                                  firstQuery,
-                                                  queryCount,
-                                                  static_cast<VkBuffer>( dstBuffer ),
-                                                  static_cast<VkDeviceSize>( dstOffset ),
-                                                  static_cast<VkDeviceSize>( stride ),
-                                                  static_cast<VkQueryResultFlags>( flags ) );
-    }
-
-    VULKAN_HPP_INLINE void
-      CommandBuffer::cuLaunchKernelNVX( const CuLaunchInfoNVX & launchInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCuLaunchKernelNVX &&
-                         "Function <vkCmdCuLaunchKernelNVX> needs extension <VK_NVX_binary_import> enabled!" );
-
-      getDispatcher()->vkCmdCuLaunchKernelNVX( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                               reinterpret_cast<const VkCuLaunchInfoNVX *>( &launchInfo ) );
-    }
-
-    VULKAN_HPP_INLINE void
-      CommandBuffer::debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT & markerInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDebugMarkerBeginEXT &&
-                         "Function <vkCmdDebugMarkerBeginEXT> needs extension <VK_EXT_debug_marker> enabled!" );
-
-      getDispatcher()->vkCmdDebugMarkerBeginEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                                 reinterpret_cast<const VkDebugMarkerMarkerInfoEXT *>( &markerInfo ) );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::debugMarkerEndEXT() const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDebugMarkerEndEXT &&
-                         "Function <vkCmdDebugMarkerEndEXT> needs extension <VK_EXT_debug_marker> enabled!" );
-
-      getDispatcher()->vkCmdDebugMarkerEndEXT( static_cast<VkCommandBuffer>( m_commandBuffer ) );
-    }
-
-    VULKAN_HPP_INLINE void
-      CommandBuffer::debugMarkerInsertEXT( const DebugMarkerMarkerInfoEXT & markerInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDebugMarkerInsertEXT &&
-                         "Function <vkCmdDebugMarkerInsertEXT> needs extension <VK_EXT_debug_marker> enabled!" );
-
-      getDispatcher()->vkCmdDebugMarkerInsertEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                                  reinterpret_cast<const VkDebugMarkerMarkerInfoEXT *>( &markerInfo ) );
-    }
-
-#  if defined( VK_ENABLE_BETA_EXTENSIONS )
-    VULKAN_HPP_INLINE void
-      CommandBuffer::decodeVideoKHR( const VideoDecodeInfoKHR & frameInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDecodeVideoKHR &&
-                         "Function <vkCmdDecodeVideoKHR> needs extension <VK_KHR_video_decode_queue> enabled!" );
-
-      getDispatcher()->vkCmdDecodeVideoKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                            reinterpret_cast<const VkVideoDecodeInfoKHR *>( &frameInfo ) );
-    }
-#  endif /*VK_ENABLE_BETA_EXTENSIONS*/
-
-    VULKAN_HPP_INLINE void CommandBuffer::dispatch( uint32_t groupCountX,
-                                                    uint32_t groupCountY,
-                                                    uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT
-    {
-      getDispatcher()->vkCmdDispatch(
-        static_cast<VkCommandBuffer>( m_commandBuffer ), groupCountX, groupCountY, groupCountZ );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::dispatchBase( uint32_t baseGroupX,
-                                                        uint32_t baseGroupY,
-                                                        uint32_t baseGroupZ,
-                                                        uint32_t groupCountX,
-                                                        uint32_t groupCountY,
-                                                        uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT
-    {
-      getDispatcher()->vkCmdDispatchBase( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                          baseGroupX,
-                                          baseGroupY,
-                                          baseGroupZ,
-                                          groupCountX,
-                                          groupCountY,
-                                          groupCountZ );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::dispatchBaseKHR( uint32_t baseGroupX,
-                                                           uint32_t baseGroupY,
-                                                           uint32_t baseGroupZ,
-                                                           uint32_t groupCountX,
-                                                           uint32_t groupCountY,
-                                                           uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDispatchBaseKHR &&
-                         "Function <vkCmdDispatchBaseKHR> needs extension <VK_KHR_device_group> enabled!" );
-
-      getDispatcher()->vkCmdDispatchBaseKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                             baseGroupX,
-                                             baseGroupY,
-                                             baseGroupZ,
-                                             groupCountX,
-                                             groupCountY,
-                                             groupCountZ );
-    }
-
-    VULKAN_HPP_INLINE void
-      CommandBuffer::dispatchIndirect( VULKAN_HPP_NAMESPACE::Buffer     buffer,
-                                       VULKAN_HPP_NAMESPACE::DeviceSize offset ) const VULKAN_HPP_NOEXCEPT
-    {
-      getDispatcher()->vkCmdDispatchIndirect( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                              static_cast<VkBuffer>( buffer ),
-                                              static_cast<VkDeviceSize>( offset ) );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::draw( uint32_t vertexCount,
-                                                uint32_t instanceCount,
-                                                uint32_t firstVertex,
-                                                uint32_t firstInstance ) const VULKAN_HPP_NOEXCEPT
-    {
-      getDispatcher()->vkCmdDraw(
-        static_cast<VkCommandBuffer>( m_commandBuffer ), vertexCount, instanceCount, firstVertex, firstInstance );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::drawIndexed( uint32_t indexCount,
-                                                       uint32_t instanceCount,
-                                                       uint32_t firstIndex,
-                                                       int32_t  vertexOffset,
-                                                       uint32_t firstInstance ) const VULKAN_HPP_NOEXCEPT
-    {
-      getDispatcher()->vkCmdDrawIndexed( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                         indexCount,
-                                         instanceCount,
-                                         firstIndex,
-                                         vertexOffset,
-                                         firstInstance );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirect( VULKAN_HPP_NAMESPACE::Buffer     buffer,
-                                                               VULKAN_HPP_NAMESPACE::DeviceSize offset,
-                                                               uint32_t                         drawCount,
-                                                               uint32_t stride ) const VULKAN_HPP_NOEXCEPT
-    {
-      getDispatcher()->vkCmdDrawIndexedIndirect( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                                 static_cast<VkBuffer>( buffer ),
-                                                 static_cast<VkDeviceSize>( offset ),
-                                                 drawCount,
-                                                 stride );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCount( VULKAN_HPP_NAMESPACE::Buffer     buffer,
-                                                                    VULKAN_HPP_NAMESPACE::DeviceSize offset,
-                                                                    VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
-                                                                    VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
-                                                                    uint32_t                         maxDrawCount,
-                                                                    uint32_t stride ) const VULKAN_HPP_NOEXCEPT
-    {
-      getDispatcher()->vkCmdDrawIndexedIndirectCount( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                                      static_cast<VkBuffer>( buffer ),
-                                                      static_cast<VkDeviceSize>( offset ),
-                                                      static_cast<VkBuffer>( countBuffer ),
-                                                      static_cast<VkDeviceSize>( countBufferOffset ),
-                                                      maxDrawCount,
-                                                      stride );
-    }
-
-    VULKAN_HPP_INLINE void
-      CommandBuffer::drawIndexedIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer     buffer,
-                                                  VULKAN_HPP_NAMESPACE::DeviceSize offset,
-                                                  VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
-                                                  VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
-                                                  uint32_t                         maxDrawCount,
-                                                  uint32_t                         stride ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkCmdDrawIndexedIndirectCountAMD &&
-        "Function <vkCmdDrawIndexedIndirectCountAMD> needs extension <VK_AMD_draw_indirect_count> enabled!" );
-
-      getDispatcher()->vkCmdDrawIndexedIndirectCountAMD( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                                         static_cast<VkBuffer>( buffer ),
-                                                         static_cast<VkDeviceSize>( offset ),
-                                                         static_cast<VkBuffer>( countBuffer ),
-                                                         static_cast<VkDeviceSize>( countBufferOffset ),
-                                                         maxDrawCount,
-                                                         stride );
-    }
-
-    VULKAN_HPP_INLINE void
-      CommandBuffer::drawIndexedIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer     buffer,
-                                                  VULKAN_HPP_NAMESPACE::DeviceSize offset,
-                                                  VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
-                                                  VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
-                                                  uint32_t                         maxDrawCount,
-                                                  uint32_t                         stride ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkCmdDrawIndexedIndirectCountKHR &&
-        "Function <vkCmdDrawIndexedIndirectCountKHR> needs extension <VK_KHR_draw_indirect_count> enabled!" );
-
-      getDispatcher()->vkCmdDrawIndexedIndirectCountKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                                         static_cast<VkBuffer>( buffer ),
-                                                         static_cast<VkDeviceSize>( offset ),
-                                                         static_cast<VkBuffer>( countBuffer ),
-                                                         static_cast<VkDeviceSize>( countBufferOffset ),
-                                                         maxDrawCount,
-                                                         stride );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::drawIndirect( VULKAN_HPP_NAMESPACE::Buffer     buffer,
-                                                        VULKAN_HPP_NAMESPACE::DeviceSize offset,
-                                                        uint32_t                         drawCount,
-                                                        uint32_t stride ) const VULKAN_HPP_NOEXCEPT
-    {
-      getDispatcher()->vkCmdDrawIndirect( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                          static_cast<VkBuffer>( buffer ),
-                                          static_cast<VkDeviceSize>( offset ),
-                                          drawCount,
-                                          stride );
-    }
-
-    VULKAN_HPP_INLINE void
-      CommandBuffer::drawIndirectByteCountEXT( uint32_t                         instanceCount,
-                                               uint32_t                         firstInstance,
-                                               VULKAN_HPP_NAMESPACE::Buffer     counterBuffer,
-                                               VULKAN_HPP_NAMESPACE::DeviceSize counterBufferOffset,
-                                               uint32_t                         counterOffset,
-                                               uint32_t                         vertexStride ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkCmdDrawIndirectByteCountEXT &&
-        "Function <vkCmdDrawIndirectByteCountEXT> needs extension <VK_EXT_transform_feedback> enabled!" );
-
-      getDispatcher()->vkCmdDrawIndirectByteCountEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                                      instanceCount,
-                                                      firstInstance,
-                                                      static_cast<VkBuffer>( counterBuffer ),
-                                                      static_cast<VkDeviceSize>( counterBufferOffset ),
-                                                      counterOffset,
-                                                      vertexStride );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCount( VULKAN_HPP_NAMESPACE::Buffer     buffer,
-                                                             VULKAN_HPP_NAMESPACE::DeviceSize offset,
-                                                             VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
-                                                             VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
-                                                             uint32_t                         maxDrawCount,
-                                                             uint32_t stride ) const VULKAN_HPP_NOEXCEPT
-    {
-      getDispatcher()->vkCmdDrawIndirectCount( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                               static_cast<VkBuffer>( buffer ),
-                                               static_cast<VkDeviceSize>( offset ),
-                                               static_cast<VkBuffer>( countBuffer ),
-                                               static_cast<VkDeviceSize>( countBufferOffset ),
-                                               maxDrawCount,
-                                               stride );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer     buffer,
-                                                                VULKAN_HPP_NAMESPACE::DeviceSize offset,
-                                                                VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
-                                                                VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
-                                                                uint32_t                         maxDrawCount,
-                                                                uint32_t stride ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawIndirectCountAMD &&
-                         "Function <vkCmdDrawIndirectCountAMD> needs extension <VK_AMD_draw_indirect_count> enabled!" );
-
-      getDispatcher()->vkCmdDrawIndirectCountAMD( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                                  static_cast<VkBuffer>( buffer ),
-                                                  static_cast<VkDeviceSize>( offset ),
-                                                  static_cast<VkBuffer>( countBuffer ),
-                                                  static_cast<VkDeviceSize>( countBufferOffset ),
-                                                  maxDrawCount,
-                                                  stride );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer     buffer,
-                                                                VULKAN_HPP_NAMESPACE::DeviceSize offset,
-                                                                VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
-                                                                VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
-                                                                uint32_t                         maxDrawCount,
-                                                                uint32_t stride ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawIndirectCountKHR &&
-                         "Function <vkCmdDrawIndirectCountKHR> needs extension <VK_KHR_draw_indirect_count> enabled!" );
-
-      getDispatcher()->vkCmdDrawIndirectCountKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                                  static_cast<VkBuffer>( buffer ),
-                                                  static_cast<VkDeviceSize>( offset ),
-                                                  static_cast<VkBuffer>( countBuffer ),
-                                                  static_cast<VkDeviceSize>( countBufferOffset ),
-                                                  maxDrawCount,
-                                                  stride );
-    }
-
-    VULKAN_HPP_INLINE void
-      CommandBuffer::drawMeshTasksIndirectCountNV( VULKAN_HPP_NAMESPACE::Buffer     buffer,
-                                                   VULKAN_HPP_NAMESPACE::DeviceSize offset,
-                                                   VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
-                                                   VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
-                                                   uint32_t                         maxDrawCount,
-                                                   uint32_t                         stride ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawMeshTasksIndirectCountNV &&
-                         "Function <vkCmdDrawMeshTasksIndirectCountNV> needs extension <VK_NV_mesh_shader> enabled!" );
-
-      getDispatcher()->vkCmdDrawMeshTasksIndirectCountNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                                          static_cast<VkBuffer>( buffer ),
-                                                          static_cast<VkDeviceSize>( offset ),
-                                                          static_cast<VkBuffer>( countBuffer ),
-                                                          static_cast<VkDeviceSize>( countBufferOffset ),
-                                                          maxDrawCount,
-                                                          stride );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectNV( VULKAN_HPP_NAMESPACE::Buffer     buffer,
-                                                                   VULKAN_HPP_NAMESPACE::DeviceSize offset,
-                                                                   uint32_t                         drawCount,
-                                                                   uint32_t stride ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawMeshTasksIndirectNV &&
-                         "Function <vkCmdDrawMeshTasksIndirectNV> needs extension <VK_NV_mesh_shader> enabled!" );
-
-      getDispatcher()->vkCmdDrawMeshTasksIndirectNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                                     static_cast<VkBuffer>( buffer ),
-                                                     static_cast<VkDeviceSize>( offset ),
-                                                     drawCount,
-                                                     stride );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksNV( uint32_t taskCount,
-                                                           uint32_t firstTask ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawMeshTasksNV &&
-                         "Function <vkCmdDrawMeshTasksNV> needs extension <VK_NV_mesh_shader> enabled!" );
-
-      getDispatcher()->vkCmdDrawMeshTasksNV( static_cast<VkCommandBuffer>( m_commandBuffer ), taskCount, firstTask );
-    }
-
-#  if defined( VK_ENABLE_BETA_EXTENSIONS )
     VULKAN_HPP_INLINE void
       CommandBuffer::encodeVideoKHR( const VideoEncodeInfoKHR & encodeInfo ) const VULKAN_HPP_NOEXCEPT
     {
@@ -12384,484 +14534,7 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
-    VULKAN_HPP_INLINE void CommandBuffer::endConditionalRenderingEXT() const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkCmdEndConditionalRenderingEXT &&
-        "Function <vkCmdEndConditionalRenderingEXT> needs extension <VK_EXT_conditional_rendering> enabled!" );
-
-      getDispatcher()->vkCmdEndConditionalRenderingEXT( static_cast<VkCommandBuffer>( m_commandBuffer ) );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::endDebugUtilsLabelEXT() const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndDebugUtilsLabelEXT &&
-                         "Function <vkCmdEndDebugUtilsLabelEXT> needs extension <VK_EXT_debug_utils> enabled!" );
-
-      getDispatcher()->vkCmdEndDebugUtilsLabelEXT( static_cast<VkCommandBuffer>( m_commandBuffer ) );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::endQuery( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
-                                                    uint32_t                        query ) const VULKAN_HPP_NOEXCEPT
-    {
-      getDispatcher()->vkCmdEndQuery(
-        static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkQueryPool>( queryPool ), query );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::endQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
-                                                              uint32_t                        query,
-                                                              uint32_t index ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndQueryIndexedEXT &&
-                         "Function <vkCmdEndQueryIndexedEXT> needs extension <VK_EXT_transform_feedback> enabled!" );
-
-      getDispatcher()->vkCmdEndQueryIndexedEXT(
-        static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkQueryPool>( queryPool ), query, index );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::endRenderPass() const VULKAN_HPP_NOEXCEPT
-    {
-      getDispatcher()->vkCmdEndRenderPass( static_cast<VkCommandBuffer>( m_commandBuffer ) );
-    }
-
-    VULKAN_HPP_INLINE void
-      CommandBuffer::endRenderPass2( const SubpassEndInfo & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      getDispatcher()->vkCmdEndRenderPass2( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                            reinterpret_cast<const VkSubpassEndInfo *>( &subpassEndInfo ) );
-    }
-
-    VULKAN_HPP_INLINE void
-      CommandBuffer::endRenderPass2KHR( const SubpassEndInfo & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndRenderPass2KHR &&
-                         "Function <vkCmdEndRenderPass2KHR> needs extension <VK_KHR_create_renderpass2> enabled!" );
-
-      getDispatcher()->vkCmdEndRenderPass2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                               reinterpret_cast<const VkSubpassEndInfo *>( &subpassEndInfo ) );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::endTransformFeedbackEXT(
-      uint32_t                                                   firstCounterBuffer,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &     counterBuffers,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets ) const
-      VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkCmdEndTransformFeedbackEXT &&
-        "Function <vkCmdEndTransformFeedbackEXT> needs extension <VK_EXT_transform_feedback> enabled!" );
-
-#  ifdef VULKAN_HPP_NO_EXCEPTIONS
-      VULKAN_HPP_ASSERT( counterBufferOffsets.empty() || counterBuffers.size() == counterBufferOffsets.size() );
-#  else
-      if ( !counterBufferOffsets.empty() && counterBuffers.size() != counterBufferOffsets.size() )
-      {
-        throw LogicError(
-          VULKAN_HPP_NAMESPACE_STRING
-          "::CommandBuffer::endTransformFeedbackEXT: counterBuffers.size() != counterBufferOffsets.size()" );
-      }
-#  endif /*VULKAN_HPP_NO_EXCEPTIONS*/
-
-      getDispatcher()->vkCmdEndTransformFeedbackEXT(
-        static_cast<VkCommandBuffer>( m_commandBuffer ),
-        firstCounterBuffer,
-        counterBuffers.size(),
-        reinterpret_cast<const VkBuffer *>( counterBuffers.data() ),
-        reinterpret_cast<const VkDeviceSize *>( counterBufferOffsets.data() ) );
-    }
-
-#  if defined( VK_ENABLE_BETA_EXTENSIONS )
-    VULKAN_HPP_INLINE void
-      CommandBuffer::endVideoCodingKHR( const VideoEndCodingInfoKHR & endCodingInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndVideoCodingKHR &&
-                         "Function <vkCmdEndVideoCodingKHR> needs extension <VK_KHR_video_queue> enabled!" );
-
-      getDispatcher()->vkCmdEndVideoCodingKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                               reinterpret_cast<const VkVideoEndCodingInfoKHR *>( &endCodingInfo ) );
-    }
-#  endif /*VK_ENABLE_BETA_EXTENSIONS*/
-
-    VULKAN_HPP_INLINE void CommandBuffer::executeCommands(
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers ) const VULKAN_HPP_NOEXCEPT
-    {
-      getDispatcher()->vkCmdExecuteCommands( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                             commandBuffers.size(),
-                                             reinterpret_cast<const VkCommandBuffer *>( commandBuffers.data() ) );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::executeGeneratedCommandsNV(
-      VULKAN_HPP_NAMESPACE::Bool32    isPreprocessed,
-      const GeneratedCommandsInfoNV & generatedCommandsInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkCmdExecuteGeneratedCommandsNV &&
-        "Function <vkCmdExecuteGeneratedCommandsNV> needs extension <VK_NV_device_generated_commands> enabled!" );
-
-      getDispatcher()->vkCmdExecuteGeneratedCommandsNV(
-        static_cast<VkCommandBuffer>( m_commandBuffer ),
-        static_cast<VkBool32>( isPreprocessed ),
-        reinterpret_cast<const VkGeneratedCommandsInfoNV *>( &generatedCommandsInfo ) );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::fillBuffer( VULKAN_HPP_NAMESPACE::Buffer     dstBuffer,
-                                                      VULKAN_HPP_NAMESPACE::DeviceSize dstOffset,
-                                                      VULKAN_HPP_NAMESPACE::DeviceSize size,
-                                                      uint32_t                         data ) const VULKAN_HPP_NOEXCEPT
-    {
-      getDispatcher()->vkCmdFillBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                        static_cast<VkBuffer>( dstBuffer ),
-                                        static_cast<VkDeviceSize>( dstOffset ),
-                                        static_cast<VkDeviceSize>( size ),
-                                        data );
-    }
-
-    VULKAN_HPP_INLINE void
-      CommandBuffer::insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdInsertDebugUtilsLabelEXT &&
-                         "Function <vkCmdInsertDebugUtilsLabelEXT> needs extension <VK_EXT_debug_utils> enabled!" );
-
-      getDispatcher()->vkCmdInsertDebugUtilsLabelEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                                      reinterpret_cast<const VkDebugUtilsLabelEXT *>( &labelInfo ) );
-    }
-
-    VULKAN_HPP_INLINE void
-      CommandBuffer::nextSubpass( VULKAN_HPP_NAMESPACE::SubpassContents contents ) const VULKAN_HPP_NOEXCEPT
-    {
-      getDispatcher()->vkCmdNextSubpass( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                         static_cast<VkSubpassContents>( contents ) );
-    }
-
-    VULKAN_HPP_INLINE void
-      CommandBuffer::nextSubpass2( const SubpassBeginInfo & subpassBeginInfo,
-                                   const SubpassEndInfo &   subpassEndInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      getDispatcher()->vkCmdNextSubpass2( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                          reinterpret_cast<const VkSubpassBeginInfo *>( &subpassBeginInfo ),
-                                          reinterpret_cast<const VkSubpassEndInfo *>( &subpassEndInfo ) );
-    }
-
-    VULKAN_HPP_INLINE void
-      CommandBuffer::nextSubpass2KHR( const SubpassBeginInfo & subpassBeginInfo,
-                                      const SubpassEndInfo &   subpassEndInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdNextSubpass2KHR &&
-                         "Function <vkCmdNextSubpass2KHR> needs extension <VK_KHR_create_renderpass2> enabled!" );
-
-      getDispatcher()->vkCmdNextSubpass2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                             reinterpret_cast<const VkSubpassBeginInfo *>( &subpassBeginInfo ),
-                                             reinterpret_cast<const VkSubpassEndInfo *>( &subpassEndInfo ) );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier(
-      VULKAN_HPP_NAMESPACE::PipelineStageFlags                            srcStageMask,
-      VULKAN_HPP_NAMESPACE::PipelineStageFlags                            dstStageMask,
-      VULKAN_HPP_NAMESPACE::DependencyFlags                               dependencyFlags,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const &       memoryBarriers,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const & bufferMemoryBarriers,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const & imageMemoryBarriers ) const VULKAN_HPP_NOEXCEPT
-    {
-      getDispatcher()->vkCmdPipelineBarrier(
-        static_cast<VkCommandBuffer>( m_commandBuffer ),
-        static_cast<VkPipelineStageFlags>( srcStageMask ),
-        static_cast<VkPipelineStageFlags>( dstStageMask ),
-        static_cast<VkDependencyFlags>( dependencyFlags ),
-        memoryBarriers.size(),
-        reinterpret_cast<const VkMemoryBarrier *>( memoryBarriers.data() ),
-        bufferMemoryBarriers.size(),
-        reinterpret_cast<const VkBufferMemoryBarrier *>( bufferMemoryBarriers.data() ),
-        imageMemoryBarriers.size(),
-        reinterpret_cast<const VkImageMemoryBarrier *>( imageMemoryBarriers.data() ) );
-    }
-
-    VULKAN_HPP_INLINE void
-      CommandBuffer::pipelineBarrier2KHR( const DependencyInfoKHR & dependencyInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdPipelineBarrier2KHR &&
-                         "Function <vkCmdPipelineBarrier2KHR> needs extension <VK_KHR_synchronization2> enabled!" );
-
-      getDispatcher()->vkCmdPipelineBarrier2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                                 reinterpret_cast<const VkDependencyInfoKHR *>( &dependencyInfo ) );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::preprocessGeneratedCommandsNV(
-      const GeneratedCommandsInfoNV & generatedCommandsInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkCmdPreprocessGeneratedCommandsNV &&
-        "Function <vkCmdPreprocessGeneratedCommandsNV> needs extension <VK_NV_device_generated_commands> enabled!" );
-
-      getDispatcher()->vkCmdPreprocessGeneratedCommandsNV(
-        static_cast<VkCommandBuffer>( m_commandBuffer ),
-        reinterpret_cast<const VkGeneratedCommandsInfoNV *>( &generatedCommandsInfo ) );
-    }
-
-    template <typename T>
-    VULKAN_HPP_INLINE void CommandBuffer::pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout   layout,
-                                                         VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags,
-                                                         uint32_t                               offset,
-                                                         ArrayProxy<const T> const & values ) const VULKAN_HPP_NOEXCEPT
-    {
-      getDispatcher()->vkCmdPushConstants( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                           static_cast<VkPipelineLayout>( layout ),
-                                           static_cast<VkShaderStageFlags>( stageFlags ),
-                                           offset,
-                                           values.size() * sizeof( T ),
-                                           reinterpret_cast<const void *>( values.data() ) );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetKHR(
-      VULKAN_HPP_NAMESPACE::PipelineBindPoint                            pipelineBindPoint,
-      VULKAN_HPP_NAMESPACE::PipelineLayout                               layout,
-      uint32_t                                                           set,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdPushDescriptorSetKHR &&
-                         "Function <vkCmdPushDescriptorSetKHR> needs extension <VK_KHR_push_descriptor> enabled!" );
-
-      getDispatcher()->vkCmdPushDescriptorSetKHR(
-        static_cast<VkCommandBuffer>( m_commandBuffer ),
-        static_cast<VkPipelineBindPoint>( pipelineBindPoint ),
-        static_cast<VkPipelineLayout>( layout ),
-        set,
-        descriptorWrites.size(),
-        reinterpret_cast<const VkWriteDescriptorSet *>( descriptorWrites.data() ) );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplateKHR(
-      VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
-      VULKAN_HPP_NAMESPACE::PipelineLayout           layout,
-      uint32_t                                       set,
-      const void *                                   pData ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkCmdPushDescriptorSetWithTemplateKHR &&
-        "Function <vkCmdPushDescriptorSetWithTemplateKHR> needs extension <VK_KHR_push_descriptor> enabled!" );
-
-      getDispatcher()->vkCmdPushDescriptorSetWithTemplateKHR(
-        static_cast<VkCommandBuffer>( m_commandBuffer ),
-        static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
-        static_cast<VkPipelineLayout>( layout ),
-        set,
-        pData );
-    }
-
-    VULKAN_HPP_INLINE void
-      CommandBuffer::resetEvent( VULKAN_HPP_NAMESPACE::Event              event,
-                                 VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask ) const VULKAN_HPP_NOEXCEPT
-    {
-      getDispatcher()->vkCmdResetEvent( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                        static_cast<VkEvent>( event ),
-                                        static_cast<VkPipelineStageFlags>( stageMask ) );
-    }
-
-    VULKAN_HPP_INLINE void
-      CommandBuffer::resetEvent2KHR( VULKAN_HPP_NAMESPACE::Event                  event,
-                                     VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR stageMask ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdResetEvent2KHR &&
-                         "Function <vkCmdResetEvent2KHR> needs extension <VK_KHR_synchronization2> enabled!" );
-
-      getDispatcher()->vkCmdResetEvent2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                            static_cast<VkEvent>( event ),
-                                            static_cast<VkPipelineStageFlags2KHR>( stageMask ) );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::resetQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
-                                                          uint32_t                        firstQuery,
-                                                          uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT
-    {
-      getDispatcher()->vkCmdResetQueryPool( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                            static_cast<VkQueryPool>( queryPool ),
-                                            firstQuery,
-                                            queryCount );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::resolveImage(
-      VULKAN_HPP_NAMESPACE::Image                                  srcImage,
-      VULKAN_HPP_NAMESPACE::ImageLayout                            srcImageLayout,
-      VULKAN_HPP_NAMESPACE::Image                                  dstImage,
-      VULKAN_HPP_NAMESPACE::ImageLayout                            dstImageLayout,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageResolve> const & regions ) const VULKAN_HPP_NOEXCEPT
-    {
-      getDispatcher()->vkCmdResolveImage( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                          static_cast<VkImage>( srcImage ),
-                                          static_cast<VkImageLayout>( srcImageLayout ),
-                                          static_cast<VkImage>( dstImage ),
-                                          static_cast<VkImageLayout>( dstImageLayout ),
-                                          regions.size(),
-                                          reinterpret_cast<const VkImageResolve *>( regions.data() ) );
-    }
-
-    VULKAN_HPP_INLINE void
-      CommandBuffer::resolveImage2KHR( const ResolveImageInfo2KHR & resolveImageInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdResolveImage2KHR &&
-                         "Function <vkCmdResolveImage2KHR> needs extension <VK_KHR_copy_commands2> enabled!" );
-
-      getDispatcher()->vkCmdResolveImage2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                              reinterpret_cast<const VkResolveImageInfo2KHR *>( &resolveImageInfo ) );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::setBlendConstants( const float blendConstants[4] ) const VULKAN_HPP_NOEXCEPT
-    {
-      getDispatcher()->vkCmdSetBlendConstants( static_cast<VkCommandBuffer>( m_commandBuffer ), blendConstants );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::setCheckpointNV( const void * pCheckpointMarker ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkCmdSetCheckpointNV &&
-        "Function <vkCmdSetCheckpointNV> needs extension <VK_NV_device_diagnostic_checkpoints> enabled!" );
-
-      getDispatcher()->vkCmdSetCheckpointNV( static_cast<VkCommandBuffer>( m_commandBuffer ), pCheckpointMarker );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::setCoarseSampleOrderNV(
-      VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV                             sampleOrderType,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV> const & customSampleOrders ) const
-      VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetCoarseSampleOrderNV &&
-                         "Function <vkCmdSetCoarseSampleOrderNV> needs extension <VK_NV_shading_rate_image> enabled!" );
-
-      getDispatcher()->vkCmdSetCoarseSampleOrderNV(
-        static_cast<VkCommandBuffer>( m_commandBuffer ),
-        static_cast<VkCoarseSampleOrderTypeNV>( sampleOrderType ),
-        customSampleOrders.size(),
-        reinterpret_cast<const VkCoarseSampleOrderCustomNV *>( customSampleOrders.data() ) );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::setColorWriteEnableEXT(
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & colorWriteEnables ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkCmdSetColorWriteEnableEXT &&
-        "Function <vkCmdSetColorWriteEnableEXT> needs extension <VK_EXT_color_write_enable> enabled!" );
-
-      getDispatcher()->vkCmdSetColorWriteEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                                    colorWriteEnables.size(),
-                                                    reinterpret_cast<const VkBool32 *>( colorWriteEnables.data() ) );
-    }
-
-    VULKAN_HPP_INLINE void
-      CommandBuffer::setCullModeEXT( VULKAN_HPP_NAMESPACE::CullModeFlags cullMode ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetCullModeEXT &&
-                         "Function <vkCmdSetCullModeEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!" );
-
-      getDispatcher()->vkCmdSetCullModeEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                            static_cast<VkCullModeFlags>( cullMode ) );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::setDepthBias( float depthBiasConstantFactor,
-                                                        float depthBiasClamp,
-                                                        float depthBiasSlopeFactor ) const VULKAN_HPP_NOEXCEPT
-    {
-      getDispatcher()->vkCmdSetDepthBias( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                          depthBiasConstantFactor,
-                                          depthBiasClamp,
-                                          depthBiasSlopeFactor );
-    }
-
-    VULKAN_HPP_INLINE void
-      CommandBuffer::setDepthBiasEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkCmdSetDepthBiasEnableEXT &&
-        "Function <vkCmdSetDepthBiasEnableEXT> needs extension <VK_EXT_extended_dynamic_state2> enabled!" );
-
-      getDispatcher()->vkCmdSetDepthBiasEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                                   static_cast<VkBool32>( depthBiasEnable ) );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::setDepthBounds( float minDepthBounds,
-                                                          float maxDepthBounds ) const VULKAN_HPP_NOEXCEPT
-    {
-      getDispatcher()->vkCmdSetDepthBounds(
-        static_cast<VkCommandBuffer>( m_commandBuffer ), minDepthBounds, maxDepthBounds );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::setDepthBoundsTestEnableEXT(
-      VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkCmdSetDepthBoundsTestEnableEXT &&
-        "Function <vkCmdSetDepthBoundsTestEnableEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!" );
-
-      getDispatcher()->vkCmdSetDepthBoundsTestEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                                         static_cast<VkBool32>( depthBoundsTestEnable ) );
-    }
-
-    VULKAN_HPP_INLINE void
-      CommandBuffer::setDepthCompareOpEXT( VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkCmdSetDepthCompareOpEXT &&
-        "Function <vkCmdSetDepthCompareOpEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!" );
-
-      getDispatcher()->vkCmdSetDepthCompareOpEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                                  static_cast<VkCompareOp>( depthCompareOp ) );
-    }
-
-    VULKAN_HPP_INLINE void
-      CommandBuffer::setDepthTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkCmdSetDepthTestEnableEXT &&
-        "Function <vkCmdSetDepthTestEnableEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!" );
-
-      getDispatcher()->vkCmdSetDepthTestEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                                   static_cast<VkBool32>( depthTestEnable ) );
-    }
-
-    VULKAN_HPP_INLINE void
-      CommandBuffer::setDepthWriteEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkCmdSetDepthWriteEnableEXT &&
-        "Function <vkCmdSetDepthWriteEnableEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!" );
-
-      getDispatcher()->vkCmdSetDepthWriteEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                                    static_cast<VkBool32>( depthWriteEnable ) );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::setDeviceMask( uint32_t deviceMask ) const VULKAN_HPP_NOEXCEPT
-    {
-      getDispatcher()->vkCmdSetDeviceMask( static_cast<VkCommandBuffer>( m_commandBuffer ), deviceMask );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::setDeviceMaskKHR( uint32_t deviceMask ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDeviceMaskKHR &&
-                         "Function <vkCmdSetDeviceMaskKHR> needs extension <VK_KHR_device_group> enabled!" );
-
-      getDispatcher()->vkCmdSetDeviceMaskKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), deviceMask );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleEXT(
-      uint32_t                                               firstDiscardRectangle,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & discardRectangles ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkCmdSetDiscardRectangleEXT &&
-        "Function <vkCmdSetDiscardRectangleEXT> needs extension <VK_EXT_discard_rectangles> enabled!" );
-
-      getDispatcher()->vkCmdSetDiscardRectangleEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                                    firstDiscardRectangle,
-                                                    discardRectangles.size(),
-                                                    reinterpret_cast<const VkRect2D *>( discardRectangles.data() ) );
-    }
-
-    VULKAN_HPP_INLINE void
-      CommandBuffer::setEvent( VULKAN_HPP_NAMESPACE::Event              event,
-                               VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask ) const VULKAN_HPP_NOEXCEPT
-    {
-      getDispatcher()->vkCmdSetEvent( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                      static_cast<VkEvent>( event ),
-                                      static_cast<VkPipelineStageFlags>( stageMask ) );
-    }
+    //=== VK_KHR_synchronization2 ===
 
     VULKAN_HPP_INLINE void
       CommandBuffer::setEvent2KHR( VULKAN_HPP_NAMESPACE::Event event,
@@ -12875,448 +14548,16 @@ namespace VULKAN_HPP_NAMESPACE
                                           reinterpret_cast<const VkDependencyInfoKHR *>( &dependencyInfo ) );
     }
 
-    VULKAN_HPP_INLINE void CommandBuffer::setExclusiveScissorNV(
-      uint32_t                                               firstExclusiveScissor,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & exclusiveScissors ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetExclusiveScissorNV &&
-                         "Function <vkCmdSetExclusiveScissorNV> needs extension <VK_NV_scissor_exclusive> enabled!" );
-
-      getDispatcher()->vkCmdSetExclusiveScissorNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                                   firstExclusiveScissor,
-                                                   exclusiveScissors.size(),
-                                                   reinterpret_cast<const VkRect2D *>( exclusiveScissors.data() ) );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::setFragmentShadingRateEnumNV(
-      VULKAN_HPP_NAMESPACE::FragmentShadingRateNV                  shadingRate,
-      const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2] ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkCmdSetFragmentShadingRateEnumNV &&
-        "Function <vkCmdSetFragmentShadingRateEnumNV> needs extension <VK_NV_fragment_shading_rate_enums> enabled!" );
-
-      getDispatcher()->vkCmdSetFragmentShadingRateEnumNV(
-        static_cast<VkCommandBuffer>( m_commandBuffer ),
-        static_cast<VkFragmentShadingRateNV>( shadingRate ),
-        reinterpret_cast<const VkFragmentShadingRateCombinerOpKHR *>( combinerOps ) );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::setFragmentShadingRateKHR(
-      const Extent2D &                                             fragmentSize,
-      const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2] ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkCmdSetFragmentShadingRateKHR &&
-        "Function <vkCmdSetFragmentShadingRateKHR> needs extension <VK_KHR_fragment_shading_rate> enabled!" );
-
-      getDispatcher()->vkCmdSetFragmentShadingRateKHR(
-        static_cast<VkCommandBuffer>( m_commandBuffer ),
-        reinterpret_cast<const VkExtent2D *>( &fragmentSize ),
-        reinterpret_cast<const VkFragmentShadingRateCombinerOpKHR *>( combinerOps ) );
-    }
-
     VULKAN_HPP_INLINE void
-      CommandBuffer::setFrontFaceEXT( VULKAN_HPP_NAMESPACE::FrontFace frontFace ) const VULKAN_HPP_NOEXCEPT
+      CommandBuffer::resetEvent2KHR( VULKAN_HPP_NAMESPACE::Event                  event,
+                                     VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR stageMask ) const VULKAN_HPP_NOEXCEPT
     {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetFrontFaceEXT &&
-                         "Function <vkCmdSetFrontFaceEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!" );
+      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdResetEvent2KHR &&
+                         "Function <vkCmdResetEvent2KHR> needs extension <VK_KHR_synchronization2> enabled!" );
 
-      getDispatcher()->vkCmdSetFrontFaceEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                             static_cast<VkFrontFace>( frontFace ) );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::setLineStippleEXT( uint32_t lineStippleFactor,
-                                                             uint16_t lineStipplePattern ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetLineStippleEXT &&
-                         "Function <vkCmdSetLineStippleEXT> needs extension <VK_EXT_line_rasterization> enabled!" );
-
-      getDispatcher()->vkCmdSetLineStippleEXT(
-        static_cast<VkCommandBuffer>( m_commandBuffer ), lineStippleFactor, lineStipplePattern );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::setLineWidth( float lineWidth ) const VULKAN_HPP_NOEXCEPT
-    {
-      getDispatcher()->vkCmdSetLineWidth( static_cast<VkCommandBuffer>( m_commandBuffer ), lineWidth );
-    }
-
-    VULKAN_HPP_INLINE void
-      CommandBuffer::setLogicOpEXT( VULKAN_HPP_NAMESPACE::LogicOp logicOp ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetLogicOpEXT &&
-                         "Function <vkCmdSetLogicOpEXT> needs extension <VK_EXT_extended_dynamic_state2> enabled!" );
-
-      getDispatcher()->vkCmdSetLogicOpEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                           static_cast<VkLogicOp>( logicOp ) );
-    }
-
-    VULKAN_HPP_INLINE void
-      CommandBuffer::setPatchControlPointsEXT( uint32_t patchControlPoints ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkCmdSetPatchControlPointsEXT &&
-        "Function <vkCmdSetPatchControlPointsEXT> needs extension <VK_EXT_extended_dynamic_state2> enabled!" );
-
-      getDispatcher()->vkCmdSetPatchControlPointsEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                                      patchControlPoints );
-    }
-
-    VULKAN_HPP_INLINE void
-      CommandBuffer::setPerformanceMarkerINTEL( const PerformanceMarkerInfoINTEL & markerInfo ) const
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkCmdSetPerformanceMarkerINTEL &&
-        "Function <vkCmdSetPerformanceMarkerINTEL> needs extension <VK_INTEL_performance_query> enabled!" );
-
-      VULKAN_HPP_NAMESPACE::Result result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCmdSetPerformanceMarkerINTEL(
-          static_cast<VkCommandBuffer>( m_commandBuffer ),
-          reinterpret_cast<const VkPerformanceMarkerInfoINTEL *>( &markerInfo ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setPerformanceMarkerINTEL" );
-      }
-    }
-
-    VULKAN_HPP_INLINE void
-      CommandBuffer::setPerformanceOverrideINTEL( const PerformanceOverrideInfoINTEL & overrideInfo ) const
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkCmdSetPerformanceOverrideINTEL &&
-        "Function <vkCmdSetPerformanceOverrideINTEL> needs extension <VK_INTEL_performance_query> enabled!" );
-
-      VULKAN_HPP_NAMESPACE::Result result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCmdSetPerformanceOverrideINTEL(
-          static_cast<VkCommandBuffer>( m_commandBuffer ),
-          reinterpret_cast<const VkPerformanceOverrideInfoINTEL *>( &overrideInfo ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setPerformanceOverrideINTEL" );
-      }
-    }
-
-    VULKAN_HPP_INLINE void
-      CommandBuffer::setPerformanceStreamMarkerINTEL( const PerformanceStreamMarkerInfoINTEL & markerInfo ) const
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkCmdSetPerformanceStreamMarkerINTEL &&
-        "Function <vkCmdSetPerformanceStreamMarkerINTEL> needs extension <VK_INTEL_performance_query> enabled!" );
-
-      VULKAN_HPP_NAMESPACE::Result result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCmdSetPerformanceStreamMarkerINTEL(
-          static_cast<VkCommandBuffer>( m_commandBuffer ),
-          reinterpret_cast<const VkPerformanceStreamMarkerInfoINTEL *>( &markerInfo ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setPerformanceStreamMarkerINTEL" );
-      }
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::setPrimitiveRestartEnableEXT(
-      VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkCmdSetPrimitiveRestartEnableEXT &&
-        "Function <vkCmdSetPrimitiveRestartEnableEXT> needs extension <VK_EXT_extended_dynamic_state2> enabled!" );
-
-      getDispatcher()->vkCmdSetPrimitiveRestartEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                                          static_cast<VkBool32>( primitiveRestartEnable ) );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::setPrimitiveTopologyEXT(
-      VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkCmdSetPrimitiveTopologyEXT &&
-        "Function <vkCmdSetPrimitiveTopologyEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!" );
-
-      getDispatcher()->vkCmdSetPrimitiveTopologyEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                                     static_cast<VkPrimitiveTopology>( primitiveTopology ) );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::setRasterizerDiscardEnableEXT(
-      VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkCmdSetRasterizerDiscardEnableEXT &&
-        "Function <vkCmdSetRasterizerDiscardEnableEXT> needs extension <VK_EXT_extended_dynamic_state2> enabled!" );
-
-      getDispatcher()->vkCmdSetRasterizerDiscardEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                                           static_cast<VkBool32>( rasterizerDiscardEnable ) );
-    }
-
-    VULKAN_HPP_INLINE void
-      CommandBuffer::setRayTracingPipelineStackSizeKHR( uint32_t pipelineStackSize ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkCmdSetRayTracingPipelineStackSizeKHR &&
-        "Function <vkCmdSetRayTracingPipelineStackSizeKHR> needs extension <VK_KHR_ray_tracing_pipeline> enabled!" );
-
-      getDispatcher()->vkCmdSetRayTracingPipelineStackSizeKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                                               pipelineStackSize );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::setSampleLocationsEXT(
-      const SampleLocationsInfoEXT & sampleLocationsInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetSampleLocationsEXT &&
-                         "Function <vkCmdSetSampleLocationsEXT> needs extension <VK_EXT_sample_locations> enabled!" );
-
-      getDispatcher()->vkCmdSetSampleLocationsEXT(
-        static_cast<VkCommandBuffer>( m_commandBuffer ),
-        reinterpret_cast<const VkSampleLocationsInfoEXT *>( &sampleLocationsInfo ) );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::setScissor(
-      uint32_t firstScissor, ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors ) const VULKAN_HPP_NOEXCEPT
-    {
-      getDispatcher()->vkCmdSetScissor( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                        firstScissor,
-                                        scissors.size(),
-                                        reinterpret_cast<const VkRect2D *>( scissors.data() ) );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::setScissorWithCountEXT(
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkCmdSetScissorWithCountEXT &&
-        "Function <vkCmdSetScissorWithCountEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!" );
-
-      getDispatcher()->vkCmdSetScissorWithCountEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                                    scissors.size(),
-                                                    reinterpret_cast<const VkRect2D *>( scissors.data() ) );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::setStencilCompareMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
-                                                                 uint32_t compareMask ) const VULKAN_HPP_NOEXCEPT
-    {
-      getDispatcher()->vkCmdSetStencilCompareMask(
-        static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkStencilFaceFlags>( faceMask ), compareMask );
-    }
-
-    VULKAN_HPP_INLINE void
-      CommandBuffer::setStencilOpEXT( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
-                                      VULKAN_HPP_NAMESPACE::StencilOp        failOp,
-                                      VULKAN_HPP_NAMESPACE::StencilOp        passOp,
-                                      VULKAN_HPP_NAMESPACE::StencilOp        depthFailOp,
-                                      VULKAN_HPP_NAMESPACE::CompareOp        compareOp ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetStencilOpEXT &&
-                         "Function <vkCmdSetStencilOpEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!" );
-
-      getDispatcher()->vkCmdSetStencilOpEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                             static_cast<VkStencilFaceFlags>( faceMask ),
-                                             static_cast<VkStencilOp>( failOp ),
-                                             static_cast<VkStencilOp>( passOp ),
-                                             static_cast<VkStencilOp>( depthFailOp ),
-                                             static_cast<VkCompareOp>( compareOp ) );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::setStencilReference( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
-                                                               uint32_t reference ) const VULKAN_HPP_NOEXCEPT
-    {
-      getDispatcher()->vkCmdSetStencilReference(
-        static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkStencilFaceFlags>( faceMask ), reference );
-    }
-
-    VULKAN_HPP_INLINE void
-      CommandBuffer::setStencilTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkCmdSetStencilTestEnableEXT &&
-        "Function <vkCmdSetStencilTestEnableEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!" );
-
-      getDispatcher()->vkCmdSetStencilTestEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                                     static_cast<VkBool32>( stencilTestEnable ) );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::setStencilWriteMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
-                                                               uint32_t writeMask ) const VULKAN_HPP_NOEXCEPT
-    {
-      getDispatcher()->vkCmdSetStencilWriteMask(
-        static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkStencilFaceFlags>( faceMask ), writeMask );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::setVertexInputEXT(
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT> const &   vertexBindingDescriptions,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT> const & vertexAttributeDescriptions )
-      const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkCmdSetVertexInputEXT &&
-        "Function <vkCmdSetVertexInputEXT> needs extension <VK_EXT_vertex_input_dynamic_state> enabled!" );
-
-      getDispatcher()->vkCmdSetVertexInputEXT(
-        static_cast<VkCommandBuffer>( m_commandBuffer ),
-        vertexBindingDescriptions.size(),
-        reinterpret_cast<const VkVertexInputBindingDescription2EXT *>( vertexBindingDescriptions.data() ),
-        vertexAttributeDescriptions.size(),
-        reinterpret_cast<const VkVertexInputAttributeDescription2EXT *>( vertexAttributeDescriptions.data() ) );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::setViewport(
-      uint32_t                                                 firstViewport,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports ) const VULKAN_HPP_NOEXCEPT
-    {
-      getDispatcher()->vkCmdSetViewport( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                         firstViewport,
-                                         viewports.size(),
-                                         reinterpret_cast<const VkViewport *>( viewports.data() ) );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::setViewportShadingRatePaletteNV(
-      uint32_t firstViewport, ArrayProxy<const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV> const & shadingRatePalettes )
-      const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkCmdSetViewportShadingRatePaletteNV &&
-        "Function <vkCmdSetViewportShadingRatePaletteNV> needs extension <VK_NV_shading_rate_image> enabled!" );
-
-      getDispatcher()->vkCmdSetViewportShadingRatePaletteNV(
-        static_cast<VkCommandBuffer>( m_commandBuffer ),
-        firstViewport,
-        shadingRatePalettes.size(),
-        reinterpret_cast<const VkShadingRatePaletteNV *>( shadingRatePalettes.data() ) );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::setViewportWScalingNV(
-      uint32_t                                                           firstViewport,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::ViewportWScalingNV> const & viewportWScalings ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkCmdSetViewportWScalingNV &&
-        "Function <vkCmdSetViewportWScalingNV> needs extension <VK_NV_clip_space_w_scaling> enabled!" );
-
-      getDispatcher()->vkCmdSetViewportWScalingNV(
-        static_cast<VkCommandBuffer>( m_commandBuffer ),
-        firstViewport,
-        viewportWScalings.size(),
-        reinterpret_cast<const VkViewportWScalingNV *>( viewportWScalings.data() ) );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::setViewportWithCountEXT(
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkCmdSetViewportWithCountEXT &&
-        "Function <vkCmdSetViewportWithCountEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!" );
-
-      getDispatcher()->vkCmdSetViewportWithCountEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                                     viewports.size(),
-                                                     reinterpret_cast<const VkViewport *>( viewports.data() ) );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::traceRaysIndirectKHR(
-      const StridedDeviceAddressRegionKHR & raygenShaderBindingTable,
-      const StridedDeviceAddressRegionKHR & missShaderBindingTable,
-      const StridedDeviceAddressRegionKHR & hitShaderBindingTable,
-      const StridedDeviceAddressRegionKHR & callableShaderBindingTable,
-      VULKAN_HPP_NAMESPACE::DeviceAddress   indirectDeviceAddress ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkCmdTraceRaysIndirectKHR &&
-        "Function <vkCmdTraceRaysIndirectKHR> needs extension <VK_KHR_ray_tracing_pipeline> enabled!" );
-
-      getDispatcher()->vkCmdTraceRaysIndirectKHR(
-        static_cast<VkCommandBuffer>( m_commandBuffer ),
-        reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &raygenShaderBindingTable ),
-        reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &missShaderBindingTable ),
-        reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &hitShaderBindingTable ),
-        reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &callableShaderBindingTable ),
-        static_cast<VkDeviceAddress>( indirectDeviceAddress ) );
-    }
-
-    VULKAN_HPP_INLINE void
-      CommandBuffer::traceRaysKHR( const StridedDeviceAddressRegionKHR & raygenShaderBindingTable,
-                                   const StridedDeviceAddressRegionKHR & missShaderBindingTable,
-                                   const StridedDeviceAddressRegionKHR & hitShaderBindingTable,
-                                   const StridedDeviceAddressRegionKHR & callableShaderBindingTable,
-                                   uint32_t                              width,
-                                   uint32_t                              height,
-                                   uint32_t                              depth ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdTraceRaysKHR &&
-                         "Function <vkCmdTraceRaysKHR> needs extension <VK_KHR_ray_tracing_pipeline> enabled!" );
-
-      getDispatcher()->vkCmdTraceRaysKHR(
-        static_cast<VkCommandBuffer>( m_commandBuffer ),
-        reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &raygenShaderBindingTable ),
-        reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &missShaderBindingTable ),
-        reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &hitShaderBindingTable ),
-        reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &callableShaderBindingTable ),
-        width,
-        height,
-        depth );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::traceRaysNV( VULKAN_HPP_NAMESPACE::Buffer     raygenShaderBindingTableBuffer,
-                                                       VULKAN_HPP_NAMESPACE::DeviceSize raygenShaderBindingOffset,
-                                                       VULKAN_HPP_NAMESPACE::Buffer     missShaderBindingTableBuffer,
-                                                       VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingOffset,
-                                                       VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingStride,
-                                                       VULKAN_HPP_NAMESPACE::Buffer     hitShaderBindingTableBuffer,
-                                                       VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingOffset,
-                                                       VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingStride,
-                                                       VULKAN_HPP_NAMESPACE::Buffer callableShaderBindingTableBuffer,
-                                                       VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingOffset,
-                                                       VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingStride,
-                                                       uint32_t                         width,
-                                                       uint32_t                         height,
-                                                       uint32_t depth ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdTraceRaysNV &&
-                         "Function <vkCmdTraceRaysNV> needs extension <VK_NV_ray_tracing> enabled!" );
-
-      getDispatcher()->vkCmdTraceRaysNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                         static_cast<VkBuffer>( raygenShaderBindingTableBuffer ),
-                                         static_cast<VkDeviceSize>( raygenShaderBindingOffset ),
-                                         static_cast<VkBuffer>( missShaderBindingTableBuffer ),
-                                         static_cast<VkDeviceSize>( missShaderBindingOffset ),
-                                         static_cast<VkDeviceSize>( missShaderBindingStride ),
-                                         static_cast<VkBuffer>( hitShaderBindingTableBuffer ),
-                                         static_cast<VkDeviceSize>( hitShaderBindingOffset ),
-                                         static_cast<VkDeviceSize>( hitShaderBindingStride ),
-                                         static_cast<VkBuffer>( callableShaderBindingTableBuffer ),
-                                         static_cast<VkDeviceSize>( callableShaderBindingOffset ),
-                                         static_cast<VkDeviceSize>( callableShaderBindingStride ),
-                                         width,
-                                         height,
-                                         depth );
-    }
-
-    template <typename T>
-    VULKAN_HPP_INLINE void CommandBuffer::updateBuffer( VULKAN_HPP_NAMESPACE::Buffer     dstBuffer,
-                                                        VULKAN_HPP_NAMESPACE::DeviceSize dstOffset,
-                                                        ArrayProxy<const T> const & data ) const VULKAN_HPP_NOEXCEPT
-    {
-      getDispatcher()->vkCmdUpdateBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                          static_cast<VkBuffer>( dstBuffer ),
-                                          static_cast<VkDeviceSize>( dstOffset ),
-                                          data.size() * sizeof( T ),
-                                          reinterpret_cast<const void *>( data.data() ) );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::waitEvents(
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const &               events,
-      VULKAN_HPP_NAMESPACE::PipelineStageFlags                            srcStageMask,
-      VULKAN_HPP_NAMESPACE::PipelineStageFlags                            dstStageMask,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const &       memoryBarriers,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const & bufferMemoryBarriers,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const & imageMemoryBarriers ) const VULKAN_HPP_NOEXCEPT
-    {
-      getDispatcher()->vkCmdWaitEvents( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                        events.size(),
-                                        reinterpret_cast<const VkEvent *>( events.data() ),
-                                        static_cast<VkPipelineStageFlags>( srcStageMask ),
-                                        static_cast<VkPipelineStageFlags>( dstStageMask ),
-                                        memoryBarriers.size(),
-                                        reinterpret_cast<const VkMemoryBarrier *>( memoryBarriers.data() ),
-                                        bufferMemoryBarriers.size(),
-                                        reinterpret_cast<const VkBufferMemoryBarrier *>( bufferMemoryBarriers.data() ),
-                                        imageMemoryBarriers.size(),
-                                        reinterpret_cast<const VkImageMemoryBarrier *>( imageMemoryBarriers.data() ) );
+      getDispatcher()->vkCmdResetEvent2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                            static_cast<VkEvent>( event ),
+                                            static_cast<VkPipelineStageFlags2KHR>( stageMask ) );
     }
 
     VULKAN_HPP_INLINE void
@@ -13343,42 +14584,44 @@ namespace VULKAN_HPP_NAMESPACE
                                             reinterpret_cast<const VkDependencyInfoKHR *>( dependencyInfos.data() ) );
     }
 
-    VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesKHR(
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
-      VULKAN_HPP_NAMESPACE::QueryType                                          queryType,
-      VULKAN_HPP_NAMESPACE::QueryPool                                          queryPool,
-      uint32_t                                                                 firstQuery ) const VULKAN_HPP_NOEXCEPT
+    VULKAN_HPP_INLINE void
+      CommandBuffer::pipelineBarrier2KHR( const DependencyInfoKHR & dependencyInfo ) const VULKAN_HPP_NOEXCEPT
     {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkCmdWriteAccelerationStructuresPropertiesKHR &&
-        "Function <vkCmdWriteAccelerationStructuresPropertiesKHR> needs extension <VK_KHR_acceleration_structure> enabled!" );
+      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdPipelineBarrier2KHR &&
+                         "Function <vkCmdPipelineBarrier2KHR> needs extension <VK_KHR_synchronization2> enabled!" );
 
-      getDispatcher()->vkCmdWriteAccelerationStructuresPropertiesKHR(
-        static_cast<VkCommandBuffer>( m_commandBuffer ),
-        accelerationStructures.size(),
-        reinterpret_cast<const VkAccelerationStructureKHR *>( accelerationStructures.data() ),
-        static_cast<VkQueryType>( queryType ),
-        static_cast<VkQueryPool>( queryPool ),
-        firstQuery );
+      getDispatcher()->vkCmdPipelineBarrier2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                                 reinterpret_cast<const VkDependencyInfoKHR *>( &dependencyInfo ) );
     }
 
-    VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesNV(
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureNV> const & accelerationStructures,
-      VULKAN_HPP_NAMESPACE::QueryType                                         queryType,
-      VULKAN_HPP_NAMESPACE::QueryPool                                         queryPool,
-      uint32_t                                                                firstQuery ) const VULKAN_HPP_NOEXCEPT
+    VULKAN_HPP_INLINE void CommandBuffer::writeTimestamp2KHR( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR stage,
+                                                              VULKAN_HPP_NAMESPACE::QueryPool              queryPool,
+                                                              uint32_t query ) const VULKAN_HPP_NOEXCEPT
     {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkCmdWriteAccelerationStructuresPropertiesNV &&
-        "Function <vkCmdWriteAccelerationStructuresPropertiesNV> needs extension <VK_NV_ray_tracing> enabled!" );
+      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdWriteTimestamp2KHR &&
+                         "Function <vkCmdWriteTimestamp2KHR> needs extension <VK_KHR_synchronization2> enabled!" );
 
-      getDispatcher()->vkCmdWriteAccelerationStructuresPropertiesNV(
-        static_cast<VkCommandBuffer>( m_commandBuffer ),
-        accelerationStructures.size(),
-        reinterpret_cast<const VkAccelerationStructureNV *>( accelerationStructures.data() ),
-        static_cast<VkQueryType>( queryType ),
-        static_cast<VkQueryPool>( queryPool ),
-        firstQuery );
+      getDispatcher()->vkCmdWriteTimestamp2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                                static_cast<VkPipelineStageFlags2KHR>( stage ),
+                                                static_cast<VkQueryPool>( queryPool ),
+                                                query );
+    }
+
+    VULKAN_HPP_INLINE void Queue::submit2KHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo2KHR> const & submits,
+                                              VULKAN_HPP_NAMESPACE::Fence fence ) const
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkQueueSubmit2KHR &&
+                         "Function <vkQueueSubmit2KHR> needs extension <VK_KHR_synchronization2> enabled!" );
+
+      VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
+        getDispatcher()->vkQueueSubmit2KHR( static_cast<VkQueue>( m_queue ),
+                                            submits.size(),
+                                            reinterpret_cast<const VkSubmitInfo2KHR *>( submits.data() ),
+                                            static_cast<VkFence>( fence ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::submit2KHR" );
+      }
     }
 
     VULKAN_HPP_INLINE void CommandBuffer::writeBufferMarker2AMD( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR stage,
@@ -13396,197 +14639,105 @@ namespace VULKAN_HPP_NAMESPACE
                                                    marker );
     }
 
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::CheckpointData2NV>
+                                           Queue::getCheckpointData2NV() const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkGetQueueCheckpointData2NV &&
+                         "Function <vkGetQueueCheckpointData2NV> needs extension <VK_KHR_synchronization2> enabled!" );
+
+      uint32_t checkpointDataCount;
+      getDispatcher()->vkGetQueueCheckpointData2NV( static_cast<VkQueue>( m_queue ), &checkpointDataCount, nullptr );
+      std::vector<VULKAN_HPP_NAMESPACE::CheckpointData2NV> checkpointData( checkpointDataCount );
+      getDispatcher()->vkGetQueueCheckpointData2NV( static_cast<VkQueue>( m_queue ),
+                                                    &checkpointDataCount,
+                                                    reinterpret_cast<VkCheckpointData2NV *>( checkpointData.data() ) );
+      VULKAN_HPP_ASSERT( checkpointDataCount <= checkpointData.size() );
+      return checkpointData;
+    }
+
+    //=== VK_NV_fragment_shading_rate_enums ===
+
+    VULKAN_HPP_INLINE void CommandBuffer::setFragmentShadingRateEnumNV(
+      VULKAN_HPP_NAMESPACE::FragmentShadingRateNV                  shadingRate,
+      const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2] ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkCmdSetFragmentShadingRateEnumNV &&
+        "Function <vkCmdSetFragmentShadingRateEnumNV> needs extension <VK_NV_fragment_shading_rate_enums> enabled!" );
+
+      getDispatcher()->vkCmdSetFragmentShadingRateEnumNV(
+        static_cast<VkCommandBuffer>( m_commandBuffer ),
+        static_cast<VkFragmentShadingRateNV>( shadingRate ),
+        reinterpret_cast<const VkFragmentShadingRateCombinerOpKHR *>( combinerOps ) );
+    }
+
+    //=== VK_KHR_copy_commands2 ===
+
     VULKAN_HPP_INLINE void
-      CommandBuffer::writeBufferMarkerAMD( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage,
-                                           VULKAN_HPP_NAMESPACE::Buffer                dstBuffer,
-                                           VULKAN_HPP_NAMESPACE::DeviceSize            dstOffset,
-                                           uint32_t marker ) const VULKAN_HPP_NOEXCEPT
+      CommandBuffer::copyBuffer2KHR( const CopyBufferInfo2KHR & copyBufferInfo ) const VULKAN_HPP_NOEXCEPT
     {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdWriteBufferMarkerAMD &&
-                         "Function <vkCmdWriteBufferMarkerAMD> needs extension <VK_AMD_buffer_marker> enabled!" );
+      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyBuffer2KHR &&
+                         "Function <vkCmdCopyBuffer2KHR> needs extension <VK_KHR_copy_commands2> enabled!" );
 
-      getDispatcher()->vkCmdWriteBufferMarkerAMD( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                                  static_cast<VkPipelineStageFlagBits>( pipelineStage ),
-                                                  static_cast<VkBuffer>( dstBuffer ),
-                                                  static_cast<VkDeviceSize>( dstOffset ),
-                                                  marker );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::writeTimestamp( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage,
-                                                          VULKAN_HPP_NAMESPACE::QueryPool             queryPool,
-                                                          uint32_t query ) const VULKAN_HPP_NOEXCEPT
-    {
-      getDispatcher()->vkCmdWriteTimestamp( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                            static_cast<VkPipelineStageFlagBits>( pipelineStage ),
-                                            static_cast<VkQueryPool>( queryPool ),
-                                            query );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::writeTimestamp2KHR( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR stage,
-                                                              VULKAN_HPP_NAMESPACE::QueryPool              queryPool,
-                                                              uint32_t query ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdWriteTimestamp2KHR &&
-                         "Function <vkCmdWriteTimestamp2KHR> needs extension <VK_KHR_synchronization2> enabled!" );
-
-      getDispatcher()->vkCmdWriteTimestamp2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
-                                                static_cast<VkPipelineStageFlags2KHR>( stage ),
-                                                static_cast<VkQueryPool>( queryPool ),
-                                                query );
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::end() const
-    {
-      VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-        getDispatcher()->vkEndCommandBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::end" );
-      }
-    }
-
-    VULKAN_HPP_INLINE void CommandBuffer::reset( VULKAN_HPP_NAMESPACE::CommandBufferResetFlags flags ) const
-    {
-      VULKAN_HPP_NAMESPACE::Result result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkResetCommandBuffer(
-          static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkCommandBufferResetFlags>( flags ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::reset" );
-      }
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result DeferredOperationKHR::join() const
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkDeferredOperationJoinKHR &&
-        "Function <vkDeferredOperationJoinKHR> needs extension <VK_KHR_deferred_host_operations> enabled!" );
-
-      VULKAN_HPP_NAMESPACE::Result result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkDeferredOperationJoinKHR(
-          static_cast<VkDevice>( m_device ), static_cast<VkDeferredOperationKHR>( m_deferredOperationKHR ) ) );
-      if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) &&
-           ( result != VULKAN_HPP_NAMESPACE::Result::eThreadDoneKHR ) &&
-           ( result != VULKAN_HPP_NAMESPACE::Result::eThreadIdleKHR ) )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::DeferredOperationKHR::join" );
-      }
-      return result;
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint32_t DeferredOperationKHR::getMaxConcurrency() const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetDeferredOperationMaxConcurrencyKHR &&
-        "Function <vkGetDeferredOperationMaxConcurrencyKHR> needs extension <VK_KHR_deferred_host_operations> enabled!" );
-
-      return getDispatcher()->vkGetDeferredOperationMaxConcurrencyKHR(
-        static_cast<VkDevice>( m_device ), static_cast<VkDeferredOperationKHR>( m_deferredOperationKHR ) );
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result
-                                           DeferredOperationKHR::getResult() const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetDeferredOperationResultKHR &&
-        "Function <vkGetDeferredOperationResultKHR> needs extension <VK_KHR_deferred_host_operations> enabled!" );
-
-      return static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetDeferredOperationResultKHR(
-        static_cast<VkDevice>( m_device ), static_cast<VkDeferredOperationKHR>( m_deferredOperationKHR ) ) );
+      getDispatcher()->vkCmdCopyBuffer2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                            reinterpret_cast<const VkCopyBufferInfo2KHR *>( &copyBufferInfo ) );
     }
 
     VULKAN_HPP_INLINE void
-      DescriptorPool::reset( VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags ) const VULKAN_HPP_NOEXCEPT
+      CommandBuffer::copyImage2KHR( const CopyImageInfo2KHR & copyImageInfo ) const VULKAN_HPP_NOEXCEPT
     {
-      getDispatcher()->vkResetDescriptorPool( static_cast<VkDevice>( m_device ),
-                                              static_cast<VkDescriptorPool>( m_descriptorPool ),
-                                              static_cast<VkDescriptorPoolResetFlags>( flags ) );
+      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyImage2KHR &&
+                         "Function <vkCmdCopyImage2KHR> needs extension <VK_KHR_copy_commands2> enabled!" );
+
+      getDispatcher()->vkCmdCopyImage2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                           reinterpret_cast<const VkCopyImageInfo2KHR *>( &copyImageInfo ) );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage2KHR(
+      const CopyBufferToImageInfo2KHR & copyBufferToImageInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyBufferToImage2KHR &&
+                         "Function <vkCmdCopyBufferToImage2KHR> needs extension <VK_KHR_copy_commands2> enabled!" );
+
+      getDispatcher()->vkCmdCopyBufferToImage2KHR(
+        static_cast<VkCommandBuffer>( m_commandBuffer ),
+        reinterpret_cast<const VkCopyBufferToImageInfo2KHR *>( &copyBufferToImageInfo ) );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer2KHR(
+      const CopyImageToBufferInfo2KHR & copyImageToBufferInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyImageToBuffer2KHR &&
+                         "Function <vkCmdCopyImageToBuffer2KHR> needs extension <VK_KHR_copy_commands2> enabled!" );
+
+      getDispatcher()->vkCmdCopyImageToBuffer2KHR(
+        static_cast<VkCommandBuffer>( m_commandBuffer ),
+        reinterpret_cast<const VkCopyImageToBufferInfo2KHR *>( &copyImageToBufferInfo ) );
     }
 
     VULKAN_HPP_INLINE void
-      DescriptorSet::updateWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
-                                         const void * pData ) const VULKAN_HPP_NOEXCEPT
+      CommandBuffer::blitImage2KHR( const BlitImageInfo2KHR & blitImageInfo ) const VULKAN_HPP_NOEXCEPT
     {
-      getDispatcher()->vkUpdateDescriptorSetWithTemplate(
-        static_cast<VkDevice>( m_device ),
-        static_cast<VkDescriptorSet>( m_descriptorSet ),
-        static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
-        pData );
+      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBlitImage2KHR &&
+                         "Function <vkCmdBlitImage2KHR> needs extension <VK_KHR_copy_commands2> enabled!" );
+
+      getDispatcher()->vkCmdBlitImage2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                           reinterpret_cast<const VkBlitImageInfo2KHR *>( &blitImageInfo ) );
     }
 
     VULKAN_HPP_INLINE void
-      DescriptorSet::updateWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
-                                            const void * pData ) const VULKAN_HPP_NOEXCEPT
+      CommandBuffer::resolveImage2KHR( const ResolveImageInfo2KHR & resolveImageInfo ) const VULKAN_HPP_NOEXCEPT
     {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkUpdateDescriptorSetWithTemplateKHR &&
-        "Function <vkUpdateDescriptorSetWithTemplateKHR> needs extension <VK_KHR_descriptor_update_template> enabled!" );
+      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdResolveImage2KHR &&
+                         "Function <vkCmdResolveImage2KHR> needs extension <VK_KHR_copy_commands2> enabled!" );
 
-      getDispatcher()->vkUpdateDescriptorSetWithTemplateKHR(
-        static_cast<VkDevice>( m_device ),
-        static_cast<VkDescriptorSet>( m_descriptorSet ),
-        static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
-        pData );
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceSize
-                                           DeviceMemory::getCommitment() const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_NAMESPACE::DeviceSize committedMemoryInBytes;
-      getDispatcher()->vkGetDeviceMemoryCommitment( static_cast<VkDevice>( m_device ),
-                                                    static_cast<VkDeviceMemory>( m_deviceMemory ),
-                                                    reinterpret_cast<VkDeviceSize *>( &committedMemoryInBytes ) );
-      return committedMemoryInBytes;
+      getDispatcher()->vkCmdResolveImage2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                              reinterpret_cast<const VkResolveImageInfo2KHR *>( &resolveImageInfo ) );
     }
 
 #  if defined( VK_USE_PLATFORM_WIN32_KHR )
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE HANDLE
-      DeviceMemory::getMemoryWin32HandleNV( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleType ) const
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryWin32HandleNV &&
-                         "Function <vkGetMemoryWin32HandleNV> needs extension <VK_NV_external_memory_win32> enabled!" );
+    //=== VK_NV_acquire_winrt_display ===
 
-      HANDLE                       handle;
-      VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-        getDispatcher()->vkGetMemoryWin32HandleNV( static_cast<VkDevice>( m_device ),
-                                                   static_cast<VkDeviceMemory>( m_deviceMemory ),
-                                                   static_cast<VkExternalMemoryHandleTypeFlagsNV>( handleType ),
-                                                   &handle ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::DeviceMemory::getMemoryWin32HandleNV" );
-      }
-      return handle;
-    }
-#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE void *
-                         DeviceMemory::mapMemory( VULKAN_HPP_NAMESPACE::DeviceSize     offset,
-                               VULKAN_HPP_NAMESPACE::DeviceSize     size,
-                               VULKAN_HPP_NAMESPACE::MemoryMapFlags flags ) const
-    {
-      void *                       pData;
-      VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-        getDispatcher()->vkMapMemory( static_cast<VkDevice>( m_device ),
-                                      static_cast<VkDeviceMemory>( m_deviceMemory ),
-                                      static_cast<VkDeviceSize>( offset ),
-                                      static_cast<VkDeviceSize>( size ),
-                                      static_cast<VkMemoryMapFlags>( flags ),
-                                      &pData ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::DeviceMemory::mapMemory" );
-      }
-      return pData;
-    }
-
-    VULKAN_HPP_INLINE void DeviceMemory::unmapMemory() const VULKAN_HPP_NOEXCEPT
-    {
-      getDispatcher()->vkUnmapMemory( static_cast<VkDevice>( m_device ),
-                                      static_cast<VkDeviceMemory>( m_deviceMemory ) );
-    }
-
-#  if defined( VK_USE_PLATFORM_WIN32_KHR )
     VULKAN_HPP_INLINE void DisplayKHR::acquireWinrtNV() const
     {
       VULKAN_HPP_ASSERT( getDispatcher()->vkAcquireWinrtDisplayNV &&
@@ -13602,295 +14753,88 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR>
-                                           DisplayKHR::getModeProperties2() const
+#  if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
+    //=== VK_EXT_directfb_surface ===
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Bool32
+                                           PhysicalDevice::getDirectFBPresentationSupportEXT( uint32_t    queueFamilyIndex,
+                                                         IDirectFB & dfb ) const VULKAN_HPP_NOEXCEPT
     {
       VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetDisplayModeProperties2KHR &&
-        "Function <vkGetDisplayModeProperties2KHR> needs extension <VK_KHR_get_display_properties2> enabled!" );
+        getDispatcher()->vkGetPhysicalDeviceDirectFBPresentationSupportEXT &&
+        "Function <vkGetPhysicalDeviceDirectFBPresentationSupportEXT> needs extension <VK_EXT_directfb_surface> enabled!" );
 
-      std::vector<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR> properties;
-      uint32_t                                                     propertyCount;
-      VULKAN_HPP_NAMESPACE::Result                                 result;
-      do
-      {
-        result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-          getDispatcher()->vkGetDisplayModeProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
-                                                           static_cast<VkDisplayKHR>( m_displayKHR ),
-                                                           &propertyCount,
-                                                           nullptr ) );
-        if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount )
-        {
-          properties.resize( propertyCount );
-          result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetDisplayModeProperties2KHR(
-            static_cast<VkPhysicalDevice>( m_physicalDevice ),
-            static_cast<VkDisplayKHR>( m_displayKHR ),
-            &propertyCount,
-            reinterpret_cast<VkDisplayModeProperties2KHR *>( properties.data() ) ) );
-          VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
-        }
-      } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
-      if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( propertyCount < properties.size() ) )
-      {
-        properties.resize( propertyCount );
-      }
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::DisplayKHR::getModeProperties2" );
-      }
-      return properties;
+      return static_cast<VULKAN_HPP_NAMESPACE::Bool32>(
+        getDispatcher()->vkGetPhysicalDeviceDirectFBPresentationSupportEXT(
+          static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex, &dfb ) );
     }
+#  endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
 
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR>
-                                           DisplayKHR::getModeProperties() const
+    //=== VK_KHR_ray_tracing_pipeline ===
+
+    VULKAN_HPP_INLINE void
+      CommandBuffer::traceRaysKHR( const StridedDeviceAddressRegionKHR & raygenShaderBindingTable,
+                                   const StridedDeviceAddressRegionKHR & missShaderBindingTable,
+                                   const StridedDeviceAddressRegionKHR & hitShaderBindingTable,
+                                   const StridedDeviceAddressRegionKHR & callableShaderBindingTable,
+                                   uint32_t                              width,
+                                   uint32_t                              height,
+                                   uint32_t                              depth ) const VULKAN_HPP_NOEXCEPT
     {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkGetDisplayModePropertiesKHR &&
-                         "Function <vkGetDisplayModePropertiesKHR> needs extension <VK_KHR_display> enabled!" );
+      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdTraceRaysKHR &&
+                         "Function <vkCmdTraceRaysKHR> needs extension <VK_KHR_ray_tracing_pipeline> enabled!" );
 
-      std::vector<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR> properties;
-      uint32_t                                                    propertyCount;
-      VULKAN_HPP_NAMESPACE::Result                                result;
-      do
-      {
-        result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-          getDispatcher()->vkGetDisplayModePropertiesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
-                                                          static_cast<VkDisplayKHR>( m_displayKHR ),
-                                                          &propertyCount,
-                                                          nullptr ) );
-        if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount )
-        {
-          properties.resize( propertyCount );
-          result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetDisplayModePropertiesKHR(
-            static_cast<VkPhysicalDevice>( m_physicalDevice ),
-            static_cast<VkDisplayKHR>( m_displayKHR ),
-            &propertyCount,
-            reinterpret_cast<VkDisplayModePropertiesKHR *>( properties.data() ) ) );
-          VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
-        }
-      } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
-      if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( propertyCount < properties.size() ) )
-      {
-        properties.resize( propertyCount );
-      }
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::DisplayKHR::getModeProperties" );
-      }
-      return properties;
+      getDispatcher()->vkCmdTraceRaysKHR(
+        static_cast<VkCommandBuffer>( m_commandBuffer ),
+        reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &raygenShaderBindingTable ),
+        reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &missShaderBindingTable ),
+        reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &hitShaderBindingTable ),
+        reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &callableShaderBindingTable ),
+        width,
+        height,
+        depth );
     }
 
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR
-                                           DisplayModeKHR::getDisplayPlaneCapabilities( uint32_t planeIndex ) const
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkGetDisplayPlaneCapabilitiesKHR &&
-                         "Function <vkGetDisplayPlaneCapabilitiesKHR> needs extension <VK_KHR_display> enabled!" );
-
-      VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR capabilities;
-      VULKAN_HPP_NAMESPACE::Result                      result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetDisplayPlaneCapabilitiesKHR(
-          static_cast<VkPhysicalDevice>( m_physicalDevice ),
-          static_cast<VkDisplayModeKHR>( m_displayModeKHR ),
-          planeIndex,
-          reinterpret_cast<VkDisplayPlaneCapabilitiesKHR *>( &capabilities ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::DisplayModeKHR::getDisplayPlaneCapabilities" );
-      }
-      return capabilities;
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result Event::getStatus() const
-    {
-      VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-        getDispatcher()->vkGetEventStatus( static_cast<VkDevice>( m_device ), static_cast<VkEvent>( m_event ) ) );
-      if ( ( result != VULKAN_HPP_NAMESPACE::Result::eEventSet ) &&
-           ( result != VULKAN_HPP_NAMESPACE::Result::eEventReset ) )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Event::getStatus" );
-      }
-      return result;
-    }
-
-    VULKAN_HPP_INLINE void Event::reset() const
-    {
-      VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-        getDispatcher()->vkResetEvent( static_cast<VkDevice>( m_device ), static_cast<VkEvent>( m_event ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Event::reset" );
-      }
-    }
-
-    VULKAN_HPP_INLINE void Event::set() const
-    {
-      VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-        getDispatcher()->vkSetEvent( static_cast<VkDevice>( m_device ), static_cast<VkEvent>( m_event ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Event::set" );
-      }
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result Fence::getStatus() const
-    {
-      VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-        getDispatcher()->vkGetFenceStatus( static_cast<VkDevice>( m_device ), static_cast<VkFence>( m_fence ) ) );
-      if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) &&
-           ( result != VULKAN_HPP_NAMESPACE::Result::eNotReady ) )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Fence::getStatus" );
-      }
-      return result;
-    }
-
-    VULKAN_HPP_INLINE void Image::bindMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory,
-                                              VULKAN_HPP_NAMESPACE::DeviceSize   memoryOffset ) const
-    {
-      VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-        getDispatcher()->vkBindImageMemory( static_cast<VkDevice>( m_device ),
-                                            static_cast<VkImage>( m_image ),
-                                            static_cast<VkDeviceMemory>( memory ),
-                                            static_cast<VkDeviceSize>( memoryOffset ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Image::bindMemory" );
-      }
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT
-                                           Image::getDrmFormatModifierPropertiesEXT() const
+    template <typename T>
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<T>
+      Pipeline::getRayTracingShaderGroupHandlesKHR( uint32_t firstGroup, uint32_t groupCount, size_t dataSize ) const
     {
       VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetImageDrmFormatModifierPropertiesEXT &&
-        "Function <vkGetImageDrmFormatModifierPropertiesEXT> needs extension <VK_EXT_image_drm_format_modifier> enabled!" );
+        getDispatcher()->vkGetRayTracingShaderGroupHandlesKHR &&
+        "Function <vkGetRayTracingShaderGroupHandlesKHR> needs extension <VK_KHR_ray_tracing_pipeline> enabled!" );
 
-      VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT properties;
-      VULKAN_HPP_NAMESPACE::Result                              result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetImageDrmFormatModifierPropertiesEXT(
-          static_cast<VkDevice>( m_device ),
-          static_cast<VkImage>( m_image ),
-          reinterpret_cast<VkImageDrmFormatModifierPropertiesEXT *>( &properties ) ) );
+      VULKAN_HPP_ASSERT( dataSize % sizeof( T ) == 0 );
+      std::vector<T> data( dataSize / sizeof( T ) );
+      Result         result = static_cast<Result>(
+        getDispatcher()->vkGetRayTracingShaderGroupHandlesKHR( static_cast<VkDevice>( m_device ),
+                                                               static_cast<VkPipeline>( m_pipeline ),
+                                                               firstGroup,
+                                                               groupCount,
+                                                               data.size() * sizeof( T ),
+                                                               reinterpret_cast<void *>( data.data() ) ) );
       if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
       {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Image::getDrmFormatModifierPropertiesEXT" );
-      }
-      return properties;
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements
-                                           Image::getMemoryRequirements() const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_NAMESPACE::MemoryRequirements memoryRequirements;
-      getDispatcher()->vkGetImageMemoryRequirements( static_cast<VkDevice>( m_device ),
-                                                     static_cast<VkImage>( m_image ),
-                                                     reinterpret_cast<VkMemoryRequirements *>( &memoryRequirements ) );
-      return memoryRequirements;
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements>
-                                           Image::getSparseMemoryRequirements() const VULKAN_HPP_NOEXCEPT
-    {
-      uint32_t sparseMemoryRequirementCount;
-      getDispatcher()->vkGetImageSparseMemoryRequirements(
-        static_cast<VkDevice>( m_device ), static_cast<VkImage>( m_image ), &sparseMemoryRequirementCount, nullptr );
-      std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements> sparseMemoryRequirements(
-        sparseMemoryRequirementCount );
-      getDispatcher()->vkGetImageSparseMemoryRequirements(
-        static_cast<VkDevice>( m_device ),
-        static_cast<VkImage>( m_image ),
-        &sparseMemoryRequirementCount,
-        reinterpret_cast<VkSparseImageMemoryRequirements *>( sparseMemoryRequirements.data() ) );
-      VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() );
-      return sparseMemoryRequirements;
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::SubresourceLayout
-      Image::getSubresourceLayout( const ImageSubresource & subresource ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_NAMESPACE::SubresourceLayout layout;
-      getDispatcher()->vkGetImageSubresourceLayout( static_cast<VkDevice>( m_device ),
-                                                    static_cast<VkImage>( m_image ),
-                                                    reinterpret_cast<const VkImageSubresource *>( &subresource ),
-                                                    reinterpret_cast<VkSubresourceLayout *>( &layout ) );
-      return layout;
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX
-                                           ImageView::getAddressNVX() const
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageViewAddressNVX &&
-                         "Function <vkGetImageViewAddressNVX> needs extension <VK_NVX_image_view_handle> enabled!" );
-
-      VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX properties;
-      VULKAN_HPP_NAMESPACE::Result                        result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetImageViewAddressNVX(
-          static_cast<VkDevice>( m_device ),
-          static_cast<VkImageView>( m_imageView ),
-          reinterpret_cast<VkImageViewAddressPropertiesNVX *>( &properties ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::ImageView::getAddressNVX" );
-      }
-      return properties;
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<uint8_t> PipelineCache::getData() const
-    {
-      std::vector<uint8_t>         data;
-      size_t                       dataSize;
-      VULKAN_HPP_NAMESPACE::Result result;
-      do
-      {
-        result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPipelineCacheData(
-          static_cast<VkDevice>( m_device ), static_cast<VkPipelineCache>( m_pipelineCache ), &dataSize, nullptr ) );
-        if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && dataSize )
-        {
-          data.resize( dataSize );
-          result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-            getDispatcher()->vkGetPipelineCacheData( static_cast<VkDevice>( m_device ),
-                                                     static_cast<VkPipelineCache>( m_pipelineCache ),
-                                                     &dataSize,
-                                                     reinterpret_cast<void *>( data.data() ) ) );
-          VULKAN_HPP_ASSERT( dataSize <= data.size() );
-        }
-      } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
-      if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( dataSize < data.size() ) )
-      {
-        data.resize( dataSize );
-      }
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PipelineCache::getData" );
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Pipeline::getRayTracingShaderGroupHandlesKHR" );
       }
       return data;
     }
 
-    VULKAN_HPP_INLINE void
-      PipelineCache::merge( ArrayProxy<const VULKAN_HPP_NAMESPACE::PipelineCache> const & srcCaches ) const
+    template <typename T>
+    VULKAN_HPP_NODISCARD T Pipeline::getRayTracingShaderGroupHandleKHR( uint32_t firstGroup, uint32_t groupCount ) const
     {
-      VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-        getDispatcher()->vkMergePipelineCaches( static_cast<VkDevice>( m_device ),
-                                                static_cast<VkPipelineCache>( m_pipelineCache ),
-                                                srcCaches.size(),
-                                                reinterpret_cast<const VkPipelineCache *>( srcCaches.data() ) ) );
+      T      data;
+      Result result = static_cast<Result>(
+        getDispatcher()->vkGetRayTracingShaderGroupHandlesKHR( static_cast<VkDevice>( m_device ),
+                                                               static_cast<VkPipeline>( m_pipeline ),
+                                                               firstGroup,
+                                                               groupCount,
+                                                               sizeof( T ),
+                                                               reinterpret_cast<void *>( &data ) ) );
       if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
       {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PipelineCache::merge" );
-      }
-    }
-
-    VULKAN_HPP_INLINE void Pipeline::compileDeferredNV( uint32_t shader ) const
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkCompileDeferredNV &&
-                         "Function <vkCompileDeferredNV> needs extension <VK_NV_ray_tracing> enabled!" );
-
-      VULKAN_HPP_NAMESPACE::Result result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCompileDeferredNV(
-          static_cast<VkDevice>( m_device ), static_cast<VkPipeline>( m_pipeline ), shader ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Pipeline::compileDeferredNV" );
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Pipeline::getRayTracingShaderGroupHandleKHR" );
       }
+      return data;
     }
 
     template <typename T>
@@ -13938,88 +14882,24 @@ namespace VULKAN_HPP_NAMESPACE
       return data;
     }
 
-    template <typename T>
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<T>
-      Pipeline::getRayTracingShaderGroupHandlesKHR( uint32_t firstGroup, uint32_t groupCount, size_t dataSize ) const
+    VULKAN_HPP_INLINE void CommandBuffer::traceRaysIndirectKHR(
+      const StridedDeviceAddressRegionKHR & raygenShaderBindingTable,
+      const StridedDeviceAddressRegionKHR & missShaderBindingTable,
+      const StridedDeviceAddressRegionKHR & hitShaderBindingTable,
+      const StridedDeviceAddressRegionKHR & callableShaderBindingTable,
+      VULKAN_HPP_NAMESPACE::DeviceAddress   indirectDeviceAddress ) const VULKAN_HPP_NOEXCEPT
     {
       VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetRayTracingShaderGroupHandlesKHR &&
-        "Function <vkGetRayTracingShaderGroupHandlesKHR> needs extension <VK_KHR_ray_tracing_pipeline> enabled!" );
+        getDispatcher()->vkCmdTraceRaysIndirectKHR &&
+        "Function <vkCmdTraceRaysIndirectKHR> needs extension <VK_KHR_ray_tracing_pipeline> enabled!" );
 
-      VULKAN_HPP_ASSERT( dataSize % sizeof( T ) == 0 );
-      std::vector<T> data( dataSize / sizeof( T ) );
-      Result         result = static_cast<Result>(
-        getDispatcher()->vkGetRayTracingShaderGroupHandlesKHR( static_cast<VkDevice>( m_device ),
-                                                               static_cast<VkPipeline>( m_pipeline ),
-                                                               firstGroup,
-                                                               groupCount,
-                                                               data.size() * sizeof( T ),
-                                                               reinterpret_cast<void *>( data.data() ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Pipeline::getRayTracingShaderGroupHandlesKHR" );
-      }
-      return data;
-    }
-
-    template <typename T>
-    VULKAN_HPP_NODISCARD T Pipeline::getRayTracingShaderGroupHandleKHR( uint32_t firstGroup, uint32_t groupCount ) const
-    {
-      T      data;
-      Result result = static_cast<Result>(
-        getDispatcher()->vkGetRayTracingShaderGroupHandlesKHR( static_cast<VkDevice>( m_device ),
-                                                               static_cast<VkPipeline>( m_pipeline ),
-                                                               firstGroup,
-                                                               groupCount,
-                                                               sizeof( T ),
-                                                               reinterpret_cast<void *>( &data ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Pipeline::getRayTracingShaderGroupHandleKHR" );
-      }
-      return data;
-    }
-
-    template <typename T>
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<T>
-      Pipeline::getRayTracingShaderGroupHandlesNV( uint32_t firstGroup, uint32_t groupCount, size_t dataSize ) const
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetRayTracingShaderGroupHandlesNV &&
-        "Function <vkGetRayTracingShaderGroupHandlesNV> needs extension <VK_NV_ray_tracing> enabled!" );
-
-      VULKAN_HPP_ASSERT( dataSize % sizeof( T ) == 0 );
-      std::vector<T> data( dataSize / sizeof( T ) );
-      Result         result = static_cast<Result>(
-        getDispatcher()->vkGetRayTracingShaderGroupHandlesNV( static_cast<VkDevice>( m_device ),
-                                                              static_cast<VkPipeline>( m_pipeline ),
-                                                              firstGroup,
-                                                              groupCount,
-                                                              data.size() * sizeof( T ),
-                                                              reinterpret_cast<void *>( data.data() ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Pipeline::getRayTracingShaderGroupHandlesNV" );
-      }
-      return data;
-    }
-
-    template <typename T>
-    VULKAN_HPP_NODISCARD T Pipeline::getRayTracingShaderGroupHandleNV( uint32_t firstGroup, uint32_t groupCount ) const
-    {
-      T      data;
-      Result result = static_cast<Result>(
-        getDispatcher()->vkGetRayTracingShaderGroupHandlesNV( static_cast<VkDevice>( m_device ),
-                                                              static_cast<VkPipeline>( m_pipeline ),
-                                                              firstGroup,
-                                                              groupCount,
-                                                              sizeof( T ),
-                                                              reinterpret_cast<void *>( &data ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Pipeline::getRayTracingShaderGroupHandleNV" );
-      }
-      return data;
+      getDispatcher()->vkCmdTraceRaysIndirectKHR(
+        static_cast<VkCommandBuffer>( m_commandBuffer ),
+        reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &raygenShaderBindingTable ),
+        reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &missShaderBindingTable ),
+        reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &hitShaderBindingTable ),
+        reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &callableShaderBindingTable ),
+        static_cast<VkDeviceAddress>( indirectDeviceAddress ) );
     }
 
     VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceSize
@@ -14037,644 +14917,209 @@ namespace VULKAN_HPP_NAMESPACE
                                                                  static_cast<VkShaderGroupShaderKHR>( groupShader ) ) );
     }
 
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<uint8_t>
-      Pipeline::getShaderInfoAMD( VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage,
-                                  VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD   infoType ) const
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkGetShaderInfoAMD &&
-                         "Function <vkGetShaderInfoAMD> needs extension <VK_AMD_shader_info> enabled!" );
-
-      std::vector<uint8_t>         info;
-      size_t                       infoSize;
-      VULKAN_HPP_NAMESPACE::Result result;
-      do
-      {
-        result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-          getDispatcher()->vkGetShaderInfoAMD( static_cast<VkDevice>( m_device ),
-                                               static_cast<VkPipeline>( m_pipeline ),
-                                               static_cast<VkShaderStageFlagBits>( shaderStage ),
-                                               static_cast<VkShaderInfoTypeAMD>( infoType ),
-                                               &infoSize,
-                                               nullptr ) );
-        if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && infoSize )
-        {
-          info.resize( infoSize );
-          result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-            getDispatcher()->vkGetShaderInfoAMD( static_cast<VkDevice>( m_device ),
-                                                 static_cast<VkPipeline>( m_pipeline ),
-                                                 static_cast<VkShaderStageFlagBits>( shaderStage ),
-                                                 static_cast<VkShaderInfoTypeAMD>( infoType ),
-                                                 &infoSize,
-                                                 reinterpret_cast<void *>( info.data() ) ) );
-          VULKAN_HPP_ASSERT( infoSize <= info.size() );
-        }
-      } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
-      if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( infoSize < info.size() ) )
-      {
-        info.resize( infoSize );
-      }
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Pipeline::getShaderInfoAMD" );
-      }
-      return info;
-    }
-
-    template <typename T>
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<VULKAN_HPP_NAMESPACE::Result, std::vector<T>>
-                                           QueryPool::getResults( uint32_t                               firstQuery,
-                             uint32_t                               queryCount,
-                             size_t                                 dataSize,
-                             VULKAN_HPP_NAMESPACE::DeviceSize       stride,
-                             VULKAN_HPP_NAMESPACE::QueryResultFlags flags ) const
-    {
-      VULKAN_HPP_ASSERT( dataSize % sizeof( T ) == 0 );
-      std::vector<T> data( dataSize / sizeof( T ) );
-      Result         result =
-        static_cast<Result>( getDispatcher()->vkGetQueryPoolResults( static_cast<VkDevice>( m_device ),
-                                                                     static_cast<VkQueryPool>( m_queryPool ),
-                                                                     firstQuery,
-                                                                     queryCount,
-                                                                     data.size() * sizeof( T ),
-                                                                     reinterpret_cast<void *>( data.data() ),
-                                                                     static_cast<VkDeviceSize>( stride ),
-                                                                     static_cast<VkQueryResultFlags>( flags ) ) );
-      if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) &&
-           ( result != VULKAN_HPP_NAMESPACE::Result::eNotReady ) )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::QueryPool::getResults" );
-      }
-      return std::make_pair( result, data );
-    }
-
-    template <typename T>
-    VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::Result, T>
-                         QueryPool::getResult( uint32_t                               firstQuery,
-                            uint32_t                               queryCount,
-                            VULKAN_HPP_NAMESPACE::DeviceSize       stride,
-                            VULKAN_HPP_NAMESPACE::QueryResultFlags flags ) const
-    {
-      T      data;
-      Result result =
-        static_cast<Result>( getDispatcher()->vkGetQueryPoolResults( static_cast<VkDevice>( m_device ),
-                                                                     static_cast<VkQueryPool>( m_queryPool ),
-                                                                     firstQuery,
-                                                                     queryCount,
-                                                                     sizeof( T ),
-                                                                     reinterpret_cast<void *>( &data ),
-                                                                     static_cast<VkDeviceSize>( stride ),
-                                                                     static_cast<VkQueryResultFlags>( flags ) ) );
-      if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) &&
-           ( result != VULKAN_HPP_NAMESPACE::Result::eNotReady ) )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::QueryPool::getResult" );
-      }
-      return std::make_pair( result, data );
-    }
-
-    VULKAN_HPP_INLINE void QueryPool::reset( uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT
-    {
-      getDispatcher()->vkResetQueryPool(
-        static_cast<VkDevice>( m_device ), static_cast<VkQueryPool>( m_queryPool ), firstQuery, queryCount );
-    }
-
-    VULKAN_HPP_INLINE void QueryPool::resetEXT( uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkResetQueryPoolEXT &&
-                         "Function <vkResetQueryPoolEXT> needs extension <VK_EXT_host_query_reset> enabled!" );
-
-      getDispatcher()->vkResetQueryPoolEXT(
-        static_cast<VkDevice>( m_device ), static_cast<VkQueryPool>( m_queryPool ), firstQuery, queryCount );
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::CheckpointData2NV>
-                                           Queue::getCheckpointData2NV() const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkGetQueueCheckpointData2NV &&
-                         "Function <vkGetQueueCheckpointData2NV> needs extension <VK_KHR_synchronization2> enabled!" );
-
-      uint32_t checkpointDataCount;
-      getDispatcher()->vkGetQueueCheckpointData2NV( static_cast<VkQueue>( m_queue ), &checkpointDataCount, nullptr );
-      std::vector<VULKAN_HPP_NAMESPACE::CheckpointData2NV> checkpointData( checkpointDataCount );
-      getDispatcher()->vkGetQueueCheckpointData2NV( static_cast<VkQueue>( m_queue ),
-                                                    &checkpointDataCount,
-                                                    reinterpret_cast<VkCheckpointData2NV *>( checkpointData.data() ) );
-      VULKAN_HPP_ASSERT( checkpointDataCount <= checkpointData.size() );
-      return checkpointData;
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::CheckpointDataNV>
-                                           Queue::getCheckpointDataNV() const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetQueueCheckpointDataNV &&
-        "Function <vkGetQueueCheckpointDataNV> needs extension <VK_NV_device_diagnostic_checkpoints> enabled!" );
-
-      uint32_t checkpointDataCount;
-      getDispatcher()->vkGetQueueCheckpointDataNV( static_cast<VkQueue>( m_queue ), &checkpointDataCount, nullptr );
-      std::vector<VULKAN_HPP_NAMESPACE::CheckpointDataNV> checkpointData( checkpointDataCount );
-      getDispatcher()->vkGetQueueCheckpointDataNV( static_cast<VkQueue>( m_queue ),
-                                                   &checkpointDataCount,
-                                                   reinterpret_cast<VkCheckpointDataNV *>( checkpointData.data() ) );
-      VULKAN_HPP_ASSERT( checkpointDataCount <= checkpointData.size() );
-      return checkpointData;
-    }
-
     VULKAN_HPP_INLINE void
-      Queue::beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkQueueBeginDebugUtilsLabelEXT &&
-                         "Function <vkQueueBeginDebugUtilsLabelEXT> needs extension <VK_EXT_debug_utils> enabled!" );
-
-      getDispatcher()->vkQueueBeginDebugUtilsLabelEXT( static_cast<VkQueue>( m_queue ),
-                                                       reinterpret_cast<const VkDebugUtilsLabelEXT *>( &labelInfo ) );
-    }
-
-    VULKAN_HPP_INLINE void Queue::bindSparse( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindSparseInfo> const & bindInfo,
-                                              VULKAN_HPP_NAMESPACE::Fence fence ) const
-    {
-      VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-        getDispatcher()->vkQueueBindSparse( static_cast<VkQueue>( m_queue ),
-                                            bindInfo.size(),
-                                            reinterpret_cast<const VkBindSparseInfo *>( bindInfo.data() ),
-                                            static_cast<VkFence>( fence ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::bindSparse" );
-      }
-    }
-
-    VULKAN_HPP_INLINE void Queue::endDebugUtilsLabelEXT() const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkQueueEndDebugUtilsLabelEXT &&
-                         "Function <vkQueueEndDebugUtilsLabelEXT> needs extension <VK_EXT_debug_utils> enabled!" );
-
-      getDispatcher()->vkQueueEndDebugUtilsLabelEXT( static_cast<VkQueue>( m_queue ) );
-    }
-
-    VULKAN_HPP_INLINE void
-      Queue::insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkQueueInsertDebugUtilsLabelEXT &&
-                         "Function <vkQueueInsertDebugUtilsLabelEXT> needs extension <VK_EXT_debug_utils> enabled!" );
-
-      getDispatcher()->vkQueueInsertDebugUtilsLabelEXT( static_cast<VkQueue>( m_queue ),
-                                                        reinterpret_cast<const VkDebugUtilsLabelEXT *>( &labelInfo ) );
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result
-                                           Queue::presentKHR( const PresentInfoKHR & presentInfo ) const
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkQueuePresentKHR &&
-                         "Function <vkQueuePresentKHR> needs extension <VK_KHR_swapchain> enabled!" );
-
-      VULKAN_HPP_NAMESPACE::Result result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkQueuePresentKHR(
-          static_cast<VkQueue>( m_queue ), reinterpret_cast<const VkPresentInfoKHR *>( &presentInfo ) ) );
-      if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) &&
-           ( result != VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR ) )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::presentKHR" );
-      }
-      return result;
-    }
-
-    VULKAN_HPP_INLINE void
-      Queue::setPerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration ) const
+      CommandBuffer::setRayTracingPipelineStackSizeKHR( uint32_t pipelineStackSize ) const VULKAN_HPP_NOEXCEPT
     {
       VULKAN_HPP_ASSERT(
-        getDispatcher()->vkQueueSetPerformanceConfigurationINTEL &&
-        "Function <vkQueueSetPerformanceConfigurationINTEL> needs extension <VK_INTEL_performance_query> enabled!" );
+        getDispatcher()->vkCmdSetRayTracingPipelineStackSizeKHR &&
+        "Function <vkCmdSetRayTracingPipelineStackSizeKHR> needs extension <VK_KHR_ray_tracing_pipeline> enabled!" );
 
-      VULKAN_HPP_NAMESPACE::Result result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkQueueSetPerformanceConfigurationINTEL(
-          static_cast<VkQueue>( m_queue ), static_cast<VkPerformanceConfigurationINTEL>( configuration ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::setPerformanceConfigurationINTEL" );
-      }
+      getDispatcher()->vkCmdSetRayTracingPipelineStackSizeKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                                               pipelineStackSize );
     }
 
-    VULKAN_HPP_INLINE void Queue::submit( ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo> const & submits,
-                                          VULKAN_HPP_NAMESPACE::Fence                                fence ) const
-    {
-      VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-        getDispatcher()->vkQueueSubmit( static_cast<VkQueue>( m_queue ),
-                                        submits.size(),
-                                        reinterpret_cast<const VkSubmitInfo *>( submits.data() ),
-                                        static_cast<VkFence>( fence ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::submit" );
-      }
-    }
+    //=== VK_EXT_vertex_input_dynamic_state ===
 
-    VULKAN_HPP_INLINE void Queue::submit2KHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo2KHR> const & submits,
-                                              VULKAN_HPP_NAMESPACE::Fence fence ) const
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkQueueSubmit2KHR &&
-                         "Function <vkQueueSubmit2KHR> needs extension <VK_KHR_synchronization2> enabled!" );
-
-      VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-        getDispatcher()->vkQueueSubmit2KHR( static_cast<VkQueue>( m_queue ),
-                                            submits.size(),
-                                            reinterpret_cast<const VkSubmitInfo2KHR *>( submits.data() ),
-                                            static_cast<VkFence>( fence ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::submit2KHR" );
-      }
-    }
-
-    VULKAN_HPP_INLINE void Queue::waitIdle() const
-    {
-      VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-        getDispatcher()->vkQueueWaitIdle( static_cast<VkQueue>( m_queue ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::waitIdle" );
-      }
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Extent2D
-                                           RenderPass::getRenderAreaGranularity() const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_NAMESPACE::Extent2D granularity;
-      getDispatcher()->vkGetRenderAreaGranularity( static_cast<VkDevice>( m_device ),
-                                                   static_cast<VkRenderPass>( m_renderPass ),
-                                                   reinterpret_cast<VkExtent2D *>( &granularity ) );
-      return granularity;
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t Semaphore::getCounterValue() const
-    {
-      uint64_t                     value;
-      VULKAN_HPP_NAMESPACE::Result result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetSemaphoreCounterValue(
-          static_cast<VkDevice>( m_device ), static_cast<VkSemaphore>( m_semaphore ), &value ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Semaphore::getCounterValue" );
-      }
-      return value;
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t Semaphore::getCounterValueKHR() const
+    VULKAN_HPP_INLINE void CommandBuffer::setVertexInputEXT(
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT> const &   vertexBindingDescriptions,
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT> const & vertexAttributeDescriptions )
+      const VULKAN_HPP_NOEXCEPT
     {
       VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetSemaphoreCounterValueKHR &&
-        "Function <vkGetSemaphoreCounterValueKHR> needs extension <VK_KHR_timeline_semaphore> enabled!" );
+        getDispatcher()->vkCmdSetVertexInputEXT &&
+        "Function <vkCmdSetVertexInputEXT> needs extension <VK_EXT_vertex_input_dynamic_state> enabled!" );
 
-      uint64_t                     value;
+      getDispatcher()->vkCmdSetVertexInputEXT(
+        static_cast<VkCommandBuffer>( m_commandBuffer ),
+        vertexBindingDescriptions.size(),
+        reinterpret_cast<const VkVertexInputBindingDescription2EXT *>( vertexBindingDescriptions.data() ),
+        vertexAttributeDescriptions.size(),
+        reinterpret_cast<const VkVertexInputAttributeDescription2EXT *>( vertexAttributeDescriptions.data() ) );
+    }
+
+#  if defined( VK_USE_PLATFORM_FUCHSIA )
+    //=== VK_FUCHSIA_external_memory ===
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE zx_handle_t
+      Device::getMemoryZirconHandleFUCHSIA( const MemoryGetZirconHandleInfoFUCHSIA & getZirconHandleInfo ) const
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkGetMemoryZirconHandleFUCHSIA &&
+        "Function <vkGetMemoryZirconHandleFUCHSIA> needs extension <VK_FUCHSIA_external_memory> enabled!" );
+
+      zx_handle_t                  zirconHandle;
       VULKAN_HPP_NAMESPACE::Result result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetSemaphoreCounterValueKHR(
-          static_cast<VkDevice>( m_device ), static_cast<VkSemaphore>( m_semaphore ), &value ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Semaphore::getCounterValueKHR" );
-      }
-      return value;
-    }
-
-#  if defined( VK_USE_PLATFORM_WIN32_KHR )
-    VULKAN_HPP_INLINE void SwapchainKHR::acquireFullScreenExclusiveModeEXT() const
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkAcquireFullScreenExclusiveModeEXT &&
-        "Function <vkAcquireFullScreenExclusiveModeEXT> needs extension <VK_EXT_full_screen_exclusive> enabled!" );
-
-      VULKAN_HPP_NAMESPACE::Result result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkAcquireFullScreenExclusiveModeEXT(
-          static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchainKHR ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::acquireFullScreenExclusiveModeEXT" );
-      }
-    }
-#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<VULKAN_HPP_NAMESPACE::Result, uint32_t>
-                                           SwapchainKHR::acquireNextImage( uint64_t                        timeout,
-                                      VULKAN_HPP_NAMESPACE::Semaphore semaphore,
-                                      VULKAN_HPP_NAMESPACE::Fence     fence ) const
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkAcquireNextImageKHR &&
-                         "Function <vkAcquireNextImageKHR> needs extension <VK_KHR_swapchain> enabled!" );
-
-      uint32_t                     imageIndex;
-      VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-        getDispatcher()->vkAcquireNextImageKHR( static_cast<VkDevice>( m_device ),
-                                                static_cast<VkSwapchainKHR>( m_swapchainKHR ),
-                                                timeout,
-                                                static_cast<VkSemaphore>( semaphore ),
-                                                static_cast<VkFence>( fence ),
-                                                &imageIndex ) );
-      if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) &&
-           ( result != VULKAN_HPP_NAMESPACE::Result::eTimeout ) &&
-           ( result != VULKAN_HPP_NAMESPACE::Result::eNotReady ) &&
-           ( result != VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR ) )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::acquireNextImage" );
-      }
-      return std::make_pair( result, imageIndex );
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE>
-                                           SwapchainKHR::getPastPresentationTimingGOOGLE() const
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetPastPresentationTimingGOOGLE &&
-        "Function <vkGetPastPresentationTimingGOOGLE> needs extension <VK_GOOGLE_display_timing> enabled!" );
-
-      std::vector<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE> presentationTimings;
-      uint32_t                                                        presentationTimingCount;
-      VULKAN_HPP_NAMESPACE::Result                                    result;
-      do
-      {
-        result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-          getDispatcher()->vkGetPastPresentationTimingGOOGLE( static_cast<VkDevice>( m_device ),
-                                                              static_cast<VkSwapchainKHR>( m_swapchainKHR ),
-                                                              &presentationTimingCount,
-                                                              nullptr ) );
-        if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && presentationTimingCount )
-        {
-          presentationTimings.resize( presentationTimingCount );
-          result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPastPresentationTimingGOOGLE(
-            static_cast<VkDevice>( m_device ),
-            static_cast<VkSwapchainKHR>( m_swapchainKHR ),
-            &presentationTimingCount,
-            reinterpret_cast<VkPastPresentationTimingGOOGLE *>( presentationTimings.data() ) ) );
-          VULKAN_HPP_ASSERT( presentationTimingCount <= presentationTimings.size() );
-        }
-      } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
-      if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) &&
-           ( presentationTimingCount < presentationTimings.size() ) )
-      {
-        presentationTimings.resize( presentationTimingCount );
-      }
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::getPastPresentationTimingGOOGLE" );
-      }
-      return presentationTimings;
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE
-                                           SwapchainKHR::getRefreshCycleDurationGOOGLE() const
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetRefreshCycleDurationGOOGLE &&
-        "Function <vkGetRefreshCycleDurationGOOGLE> needs extension <VK_GOOGLE_display_timing> enabled!" );
-
-      VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE displayTimingProperties;
-      VULKAN_HPP_NAMESPACE::Result                     result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetRefreshCycleDurationGOOGLE(
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetMemoryZirconHandleFUCHSIA(
           static_cast<VkDevice>( m_device ),
-          static_cast<VkSwapchainKHR>( m_swapchainKHR ),
-          reinterpret_cast<VkRefreshCycleDurationGOOGLE *>( &displayTimingProperties ) ) );
+          reinterpret_cast<const VkMemoryGetZirconHandleInfoFUCHSIA *>( &getZirconHandleInfo ),
+          &zirconHandle ) );
       if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
       {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::getRefreshCycleDurationGOOGLE" );
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryZirconHandleFUCHSIA" );
       }
-      return displayTimingProperties;
+      return zirconHandle;
     }
 
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t
-      SwapchainKHR::getCounterEXT( VULKAN_HPP_NAMESPACE::SurfaceCounterFlagBitsEXT counter ) const
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkGetSwapchainCounterEXT &&
-                         "Function <vkGetSwapchainCounterEXT> needs extension <VK_EXT_display_control> enabled!" );
-
-      uint64_t                     counterValue;
-      VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-        getDispatcher()->vkGetSwapchainCounterEXT( static_cast<VkDevice>( m_device ),
-                                                   static_cast<VkSwapchainKHR>( m_swapchainKHR ),
-                                                   static_cast<VkSurfaceCounterFlagBitsEXT>( counter ),
-                                                   &counterValue ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::getCounterEXT" );
-      }
-      return counterValue;
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VkImage> SwapchainKHR::getImages() const
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkGetSwapchainImagesKHR &&
-                         "Function <vkGetSwapchainImagesKHR> needs extension <VK_KHR_swapchain> enabled!" );
-
-      std::vector<VkImage>         swapchainImages;
-      uint32_t                     swapchainImageCount;
-      VULKAN_HPP_NAMESPACE::Result result;
-      do
-      {
-        result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-          getDispatcher()->vkGetSwapchainImagesKHR( static_cast<VkDevice>( m_device ),
-                                                    static_cast<VkSwapchainKHR>( m_swapchainKHR ),
-                                                    &swapchainImageCount,
-                                                    nullptr ) );
-        if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && swapchainImageCount )
-        {
-          swapchainImages.resize( swapchainImageCount );
-          result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-            getDispatcher()->vkGetSwapchainImagesKHR( static_cast<VkDevice>( m_device ),
-                                                      static_cast<VkSwapchainKHR>( m_swapchainKHR ),
-                                                      &swapchainImageCount,
-                                                      swapchainImages.data() ) );
-          VULKAN_HPP_ASSERT( swapchainImageCount <= swapchainImages.size() );
-        }
-      } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
-      if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( swapchainImageCount < swapchainImages.size() ) )
-      {
-        swapchainImages.resize( swapchainImageCount );
-      }
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::getImages" );
-      }
-      return swapchainImages;
-    }
-
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result SwapchainKHR::getStatus() const
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA
+      Device::getMemoryZirconHandlePropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
+                                                      zx_handle_t zirconHandle ) const
     {
       VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetSwapchainStatusKHR &&
-        "Function <vkGetSwapchainStatusKHR> needs extension <VK_KHR_shared_presentable_image> enabled!" );
+        getDispatcher()->vkGetMemoryZirconHandlePropertiesFUCHSIA &&
+        "Function <vkGetMemoryZirconHandlePropertiesFUCHSIA> needs extension <VK_FUCHSIA_external_memory> enabled!" );
 
-      VULKAN_HPP_NAMESPACE::Result result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetSwapchainStatusKHR(
-          static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchainKHR ) ) );
-      if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) &&
-           ( result != VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR ) )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::getStatus" );
-      }
-      return result;
-    }
-
-#  if defined( VK_USE_PLATFORM_WIN32_KHR )
-    VULKAN_HPP_INLINE void SwapchainKHR::releaseFullScreenExclusiveModeEXT() const
-    {
-      VULKAN_HPP_ASSERT(
-        getDispatcher()->vkReleaseFullScreenExclusiveModeEXT &&
-        "Function <vkReleaseFullScreenExclusiveModeEXT> needs extension <VK_EXT_full_screen_exclusive> enabled!" );
-
-      VULKAN_HPP_NAMESPACE::Result result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkReleaseFullScreenExclusiveModeEXT(
-          static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchainKHR ) ) );
+      VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA memoryZirconHandleProperties;
+      VULKAN_HPP_NAMESPACE::Result                              result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetMemoryZirconHandlePropertiesFUCHSIA(
+          static_cast<VkDevice>( m_device ),
+          static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ),
+          zirconHandle,
+          reinterpret_cast<VkMemoryZirconHandlePropertiesFUCHSIA *>( &memoryZirconHandleProperties ) ) );
       if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
       {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::releaseFullScreenExclusiveModeEXT" );
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryZirconHandlePropertiesFUCHSIA" );
+      }
+      return memoryZirconHandleProperties;
+    }
+#  endif /*VK_USE_PLATFORM_FUCHSIA*/
+
+#  if defined( VK_USE_PLATFORM_FUCHSIA )
+    //=== VK_FUCHSIA_external_semaphore ===
+
+    VULKAN_HPP_INLINE void Device::importSemaphoreZirconHandleFUCHSIA(
+      const ImportSemaphoreZirconHandleInfoFUCHSIA & importSemaphoreZirconHandleInfo ) const
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkImportSemaphoreZirconHandleFUCHSIA &&
+        "Function <vkImportSemaphoreZirconHandleFUCHSIA> needs extension <VK_FUCHSIA_external_semaphore> enabled!" );
+
+      VULKAN_HPP_NAMESPACE::Result result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkImportSemaphoreZirconHandleFUCHSIA(
+          static_cast<VkDevice>( m_device ),
+          reinterpret_cast<const VkImportSemaphoreZirconHandleInfoFUCHSIA *>( &importSemaphoreZirconHandleInfo ) ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importSemaphoreZirconHandleFUCHSIA" );
       }
     }
-#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE zx_handle_t
+      Device::getSemaphoreZirconHandleFUCHSIA( const SemaphoreGetZirconHandleInfoFUCHSIA & getZirconHandleInfo ) const
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkGetSemaphoreZirconHandleFUCHSIA &&
+        "Function <vkGetSemaphoreZirconHandleFUCHSIA> needs extension <VK_FUCHSIA_external_semaphore> enabled!" );
+
+      zx_handle_t                  zirconHandle;
+      VULKAN_HPP_NAMESPACE::Result result =
+        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetSemaphoreZirconHandleFUCHSIA(
+          static_cast<VkDevice>( m_device ),
+          reinterpret_cast<const VkSemaphoreGetZirconHandleInfoFUCHSIA *>( &getZirconHandleInfo ),
+          &zirconHandle ) );
+      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
+      {
+        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreZirconHandleFUCHSIA" );
+      }
+      return zirconHandle;
+    }
+#  endif /*VK_USE_PLATFORM_FUCHSIA*/
+
+    //=== VK_EXT_extended_dynamic_state2 ===
 
     VULKAN_HPP_INLINE void
-      SwapchainKHR::setLocalDimmingAMD( VULKAN_HPP_NAMESPACE::Bool32 localDimmingEnable ) const VULKAN_HPP_NOEXCEPT
+      CommandBuffer::setPatchControlPointsEXT( uint32_t patchControlPoints ) const VULKAN_HPP_NOEXCEPT
     {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkSetLocalDimmingAMD &&
-                         "Function <vkSetLocalDimmingAMD> needs extension <VK_AMD_display_native_hdr> enabled!" );
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkCmdSetPatchControlPointsEXT &&
+        "Function <vkCmdSetPatchControlPointsEXT> needs extension <VK_EXT_extended_dynamic_state2> enabled!" );
 
-      getDispatcher()->vkSetLocalDimmingAMD( static_cast<VkDevice>( m_device ),
-                                             static_cast<VkSwapchainKHR>( m_swapchainKHR ),
-                                             static_cast<VkBool32>( localDimmingEnable ) );
+      getDispatcher()->vkCmdSetPatchControlPointsEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                                      patchControlPoints );
     }
 
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<uint8_t> ValidationCacheEXT::getData() const
+    VULKAN_HPP_INLINE void CommandBuffer::setRasterizerDiscardEnableEXT(
+      VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable ) const VULKAN_HPP_NOEXCEPT
     {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkGetValidationCacheDataEXT &&
-                         "Function <vkGetValidationCacheDataEXT> needs extension <VK_EXT_validation_cache> enabled!" );
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkCmdSetRasterizerDiscardEnableEXT &&
+        "Function <vkCmdSetRasterizerDiscardEnableEXT> needs extension <VK_EXT_extended_dynamic_state2> enabled!" );
 
-      std::vector<uint8_t>         data;
-      size_t                       dataSize;
-      VULKAN_HPP_NAMESPACE::Result result;
-      do
-      {
-        result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-          getDispatcher()->vkGetValidationCacheDataEXT( static_cast<VkDevice>( m_device ),
-                                                        static_cast<VkValidationCacheEXT>( m_validationCacheEXT ),
-                                                        &dataSize,
-                                                        nullptr ) );
-        if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && dataSize )
-        {
-          data.resize( dataSize );
-          result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-            getDispatcher()->vkGetValidationCacheDataEXT( static_cast<VkDevice>( m_device ),
-                                                          static_cast<VkValidationCacheEXT>( m_validationCacheEXT ),
-                                                          &dataSize,
-                                                          reinterpret_cast<void *>( data.data() ) ) );
-          VULKAN_HPP_ASSERT( dataSize <= data.size() );
-        }
-      } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
-      if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( dataSize < data.size() ) )
-      {
-        data.resize( dataSize );
-      }
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::ValidationCacheEXT::getData" );
-      }
-      return data;
+      getDispatcher()->vkCmdSetRasterizerDiscardEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                                           static_cast<VkBool32>( rasterizerDiscardEnable ) );
     }
 
     VULKAN_HPP_INLINE void
-      ValidationCacheEXT::merge( ArrayProxy<const VULKAN_HPP_NAMESPACE::ValidationCacheEXT> const & srcCaches ) const
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkMergeValidationCachesEXT &&
-                         "Function <vkMergeValidationCachesEXT> needs extension <VK_EXT_validation_cache> enabled!" );
-
-      VULKAN_HPP_NAMESPACE::Result result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkMergeValidationCachesEXT(
-          static_cast<VkDevice>( m_device ),
-          static_cast<VkValidationCacheEXT>( m_validationCacheEXT ),
-          srcCaches.size(),
-          reinterpret_cast<const VkValidationCacheEXT *>( srcCaches.data() ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::ValidationCacheEXT::merge" );
-      }
-    }
-
-#  if defined( VK_ENABLE_BETA_EXTENSIONS )
-    VULKAN_HPP_INLINE void VideoSessionKHR::bindMemory(
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::VideoBindMemoryKHR> const & videoSessionBindMemories ) const
-    {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkBindVideoSessionMemoryKHR &&
-                         "Function <vkBindVideoSessionMemoryKHR> needs extension <VK_KHR_video_queue> enabled!" );
-
-      VULKAN_HPP_NAMESPACE::Result result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkBindVideoSessionMemoryKHR(
-          static_cast<VkDevice>( m_device ),
-          static_cast<VkVideoSessionKHR>( m_videoSessionKHR ),
-          videoSessionBindMemories.size(),
-          reinterpret_cast<const VkVideoBindMemoryKHR *>( videoSessionBindMemories.data() ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::VideoSessionKHR::bindMemory" );
-      }
-    }
-#  endif /*VK_ENABLE_BETA_EXTENSIONS*/
-
-#  if defined( VK_ENABLE_BETA_EXTENSIONS )
-    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::VideoGetMemoryPropertiesKHR>
-                                           VideoSessionKHR::getMemoryRequirements() const
+      CommandBuffer::setDepthBiasEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable ) const VULKAN_HPP_NOEXCEPT
     {
       VULKAN_HPP_ASSERT(
-        getDispatcher()->vkGetVideoSessionMemoryRequirementsKHR &&
-        "Function <vkGetVideoSessionMemoryRequirementsKHR> needs extension <VK_KHR_video_queue> enabled!" );
+        getDispatcher()->vkCmdSetDepthBiasEnableEXT &&
+        "Function <vkCmdSetDepthBiasEnableEXT> needs extension <VK_EXT_extended_dynamic_state2> enabled!" );
 
-      std::vector<VULKAN_HPP_NAMESPACE::VideoGetMemoryPropertiesKHR> videoSessionMemoryRequirements;
-      uint32_t                                                       videoSessionMemoryRequirementsCount;
-      VULKAN_HPP_NAMESPACE::Result                                   result;
-      do
-      {
-        result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
-          getDispatcher()->vkGetVideoSessionMemoryRequirementsKHR( static_cast<VkDevice>( m_device ),
-                                                                   static_cast<VkVideoSessionKHR>( m_videoSessionKHR ),
-                                                                   &videoSessionMemoryRequirementsCount,
-                                                                   nullptr ) );
-        if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && videoSessionMemoryRequirementsCount )
-        {
-          videoSessionMemoryRequirements.resize( videoSessionMemoryRequirementsCount );
-          result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetVideoSessionMemoryRequirementsKHR(
-            static_cast<VkDevice>( m_device ),
-            static_cast<VkVideoSessionKHR>( m_videoSessionKHR ),
-            &videoSessionMemoryRequirementsCount,
-            reinterpret_cast<VkVideoGetMemoryPropertiesKHR *>( videoSessionMemoryRequirements.data() ) ) );
-          VULKAN_HPP_ASSERT( videoSessionMemoryRequirementsCount <= videoSessionMemoryRequirements.size() );
-        }
-      } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
-      if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) &&
-           ( videoSessionMemoryRequirementsCount < videoSessionMemoryRequirements.size() ) )
-      {
-        videoSessionMemoryRequirements.resize( videoSessionMemoryRequirementsCount );
-      }
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::VideoSessionKHR::getMemoryRequirements" );
-      }
-      return videoSessionMemoryRequirements;
+      getDispatcher()->vkCmdSetDepthBiasEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                                   static_cast<VkBool32>( depthBiasEnable ) );
     }
-#  endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
-#  if defined( VK_ENABLE_BETA_EXTENSIONS )
     VULKAN_HPP_INLINE void
-      VideoSessionParametersKHR::update( const VideoSessionParametersUpdateInfoKHR & updateInfo ) const
+      CommandBuffer::setLogicOpEXT( VULKAN_HPP_NAMESPACE::LogicOp logicOp ) const VULKAN_HPP_NOEXCEPT
     {
-      VULKAN_HPP_ASSERT( getDispatcher()->vkUpdateVideoSessionParametersKHR &&
-                         "Function <vkUpdateVideoSessionParametersKHR> needs extension <VK_KHR_video_queue> enabled!" );
+      VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetLogicOpEXT &&
+                         "Function <vkCmdSetLogicOpEXT> needs extension <VK_EXT_extended_dynamic_state2> enabled!" );
 
-      VULKAN_HPP_NAMESPACE::Result result =
-        static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkUpdateVideoSessionParametersKHR(
-          static_cast<VkDevice>( m_device ),
-          static_cast<VkVideoSessionParametersKHR>( m_videoSessionParametersKHR ),
-          reinterpret_cast<const VkVideoSessionParametersUpdateInfoKHR *>( &updateInfo ) ) );
-      if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
-      {
-        throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::VideoSessionParametersKHR::update" );
-      }
+      getDispatcher()->vkCmdSetLogicOpEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                           static_cast<VkLogicOp>( logicOp ) );
+    }
+
+    VULKAN_HPP_INLINE void CommandBuffer::setPrimitiveRestartEnableEXT(
+      VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkCmdSetPrimitiveRestartEnableEXT &&
+        "Function <vkCmdSetPrimitiveRestartEnableEXT> needs extension <VK_EXT_extended_dynamic_state2> enabled!" );
+
+      getDispatcher()->vkCmdSetPrimitiveRestartEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                                          static_cast<VkBool32>( primitiveRestartEnable ) );
+    }
+
+#  if defined( VK_USE_PLATFORM_SCREEN_QNX )
+    //=== VK_QNX_screen_surface ===
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Bool32
+                                           PhysicalDevice::getScreenPresentationSupportQNX( uint32_t                queueFamilyIndex,
+                                                       struct _screen_window & window ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkGetPhysicalDeviceScreenPresentationSupportQNX &&
+        "Function <vkGetPhysicalDeviceScreenPresentationSupportQNX> needs extension <VK_QNX_screen_surface> enabled!" );
+
+      return static_cast<VULKAN_HPP_NAMESPACE::Bool32>(
+        getDispatcher()->vkGetPhysicalDeviceScreenPresentationSupportQNX(
+          static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex, &window ) );
+    }
+#  endif /*VK_USE_PLATFORM_SCREEN_QNX*/
+
+    //=== VK_EXT_color_write_enable ===
+
+    VULKAN_HPP_INLINE void CommandBuffer::setColorWriteEnableEXT(
+      ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & colorWriteEnables ) const VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT(
+        getDispatcher()->vkCmdSetColorWriteEnableEXT &&
+        "Function <vkCmdSetColorWriteEnableEXT> needs extension <VK_EXT_color_write_enable> enabled!" );
+
+      getDispatcher()->vkCmdSetColorWriteEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
+                                                    colorWriteEnables.size(),
+                                                    reinterpret_cast<const VkBool32 *>( colorWriteEnables.data() ) );
     }
-#  endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #endif
   }  // namespace VULKAN_HPP_RAII_NAMESPACE