diff --git a/VulkanHppGenerator.cpp b/VulkanHppGenerator.cpp
index c33ec30..8356cbb 100644
--- a/VulkanHppGenerator.cpp
+++ b/VulkanHppGenerator.cpp
@@ -3948,14 +3948,14 @@ std::string
   }
 }
 
-std::string
-  VulkanHppGenerator::generateCommandResultGetVectorOfHandles( std::string const &              name,
-                                                               CommandData const &              commandData,
-                                                               size_t                           initialSkipCount,
-                                                               bool                             definition,
-                                                               std::map<size_t, size_t> const & vectorParamIndices,
-                                                               size_t                           returnParamIndex,
-                                                               bool                             withAllocator ) const
+std::string VulkanHppGenerator::generateCommandResultGetVectorOfHandlesOrValues(
+  std::string const &              name,
+  CommandData const &              commandData,
+  size_t                           initialSkipCount,
+  bool                             definition,
+  std::map<size_t, size_t> const & vectorParamIndices,
+  size_t                           returnParamIndex,
+  bool                             withAllocator ) const
 {
   assert( commandData.returnType == "VkResult" );
 
@@ -3966,27 +3966,29 @@ std::string
     generateArgumentListEnhanced( commandData.params, skippedParams, {}, definition, withAllocator, false, true );
   std::string commandName = generateCommandName( name, commandData.params, initialSkipCount, m_tags );
   std::string nodiscard   = generateNoDiscard( 1 < commandData.successCodes.size(), 1 < commandData.errorCodes.size() );
-  std::string handleType  = stripPrefix( commandData.params[returnParamIndex].type.type, "Vk" );
+  assert( beginsWith( commandData.params[returnParamIndex].type.type, "Vk" ) );
+  std::string elementType = stripPrefix( commandData.params[returnParamIndex].type.type, "Vk" );
   std::string returnType =
     ( commandData.successCodes.size() == 1 )
-      ? ( "typename ResultValueType<std::vector<" + handleType + ", " + handleType + "Allocator>>::type" )
-      : ( "ResultValue<std::vector<" + handleType + ", " + handleType + "Allocator>>" );
+      ? ( "typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::" + elementType + ", " + elementType +
+          "Allocator>>::type" )
+      : ( "ResultValue<std::vector<VULKAN_HPP_NAMESPACE::" + elementType + ", " + elementType + "Allocator>>" );
 
   if ( definition )
   {
     std::string const functionTemplate =
-      R"(  template <typename ${handleType}Allocator, typename Dispatch${typenameCheck}>
+      R"(  template <typename ${elementType}Allocator, typename Dispatch${typenameCheck}>
   ${nodiscard}VULKAN_HPP_INLINE ${returnType} ${className}${classSeparator}${commandName}( ${argumentList} ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
-    std::vector<${handleType}, ${handleType}Allocator> ${vectorName}( ${vectorSize}${vectorAllocator} );
+    std::vector<VULKAN_HPP_NAMESPACE::${elementType}, ${elementType}Allocator> ${vectorName}( ${vectorSize}${vectorAllocator} );
     Result result = static_cast<Result>( d.${vkCommand}( ${callArguments} ) );
     return createResultValue( result, ${vectorName}, VULKAN_HPP_NAMESPACE_STRING "::${className}${classSeparator}${commandName}"${successCodeList} );
   })";
 
     std::string typenameCheck = withAllocator
                                   ? ( ", typename B, typename std::enable_if<std::is_same<typename B::value_type, " +
-                                      handleType + ">::value, int>::type " )
+                                      elementType + ">::value, int>::type " )
                                   : "";
     std::string vectorName    = startLowerCase( stripPrefix( commandData.params[returnParamIndex].name, "p" ) );
 
@@ -3998,12 +4000,12 @@ std::string
           initialSkipCount ? stripPrefix( commandData.params[initialSkipCount - 1].type.type, "Vk" ) : "" },
         { "classSeparator", commandData.handle.empty() ? "" : "::" },
         { "commandName", commandName },
+        { "elementType", elementType },
         { "nodiscard", nodiscard },
-        { "handleType", handleType },
         { "returnType", returnType },
         { "typenameCheck", typenameCheck },
         { "successCodeList", generateSuccessCodeList( commandData.successCodes ) },
-        { "vectorAllocator", withAllocator ? ( ", " + startLowerCase( handleType ) + "Allocator" ) : "" },
+        { "vectorAllocator", withAllocator ? ( ", " + startLowerCase( elementType ) + "Allocator" ) : "" },
         { "vectorName", vectorName },
         { "vectorSize", getVectorSize( commandData.params, vectorParamIndices, returnParamIndex ) },
         { "vkCommand", name } } );
@@ -4011,26 +4013,26 @@ std::string
   else
   {
     std::string const functionTemplate =
-      R"(    template <typename ${handleType}Allocator = std::allocator<${handleType}>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE${typenameCheck}>
+      R"(    template <typename ${elementType}Allocator = std::allocator<${elementType}>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE${typenameCheck}>
     ${nodiscard}${returnType} ${commandName}( ${argumentList} ) const;)";
 
     std::string typenameCheck = withAllocator
-                                  ? ( ", typename B = " + handleType +
+                                  ? ( ", typename B = " + elementType +
                                       "Allocator, typename std::enable_if<std::is_same<typename B::value_type, " +
-                                      handleType + ">::value, int>::type = 0" )
+                                      elementType + ">::value, int>::type = 0" )
                                   : "";
 
     return replaceWithMap( functionTemplate,
                            { { "argumentList", argumentList },
                              { "commandName", commandName },
-                             { "handleType", handleType },
+                             { "elementType", elementType },
                              { "nodiscard", nodiscard },
                              { "returnType", returnType },
                              { "typenameCheck", typenameCheck } } );
   }
 }
 
-std::string VulkanHppGenerator::generateCommandResultGetVectorOfHandlesSingular(
+std::string VulkanHppGenerator::generateCommandResultGetVectorOfHandlesOrValuesSingular(
   std::string const &              name,
   CommandData const &              commandData,
   size_t                           initialSkipCount,
@@ -4050,10 +4052,11 @@ std::string VulkanHppGenerator::generateCommandResultGetVectorOfHandlesSingular(
     generateArgumentListEnhanced( commandData.params, skippedParams, singularParams, definition, false, false, true );
   std::string commandName = stripPluralS( generateCommandName( name, commandData.params, initialSkipCount, m_tags ) );
   std::string nodiscard   = generateNoDiscard( 1 < commandData.successCodes.size(), 1 < commandData.errorCodes.size() );
-  std::string handleType  = stripPrefix( commandData.params[returnParamIndex].type.type, "Vk" );
-  std::string returnType  = ( commandData.successCodes.size() == 1 )
-                              ? ( "typename ResultValueType<" + handleType + ">::type" )
-                              : ( "ResultValue<" + handleType + ">" );
+  assert( beginsWith( commandData.params[returnParamIndex].type.type, "Vk" ) );
+  std::string dataType = "VULKAN_HPP_NAMESPACE::" + stripPrefix( commandData.params[returnParamIndex].type.type, "Vk" );
+  std::string returnType = ( commandData.successCodes.size() == 1 )
+                             ? ( "typename ResultValueType<" + dataType + ">::type" )
+                             : ( "ResultValue<" + dataType + ">" );
 
   if ( definition )
   {
@@ -4062,9 +4065,9 @@ std::string VulkanHppGenerator::generateCommandResultGetVectorOfHandlesSingular(
   ${nodiscard}VULKAN_HPP_INLINE ${returnType} ${className}${classSeparator}${commandName}( ${argumentList} ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
-    ${handleType} ${handleName};
+    ${dataType} ${dataName};
     Result result = static_cast<Result>( d.${vkCommand}( ${callArguments} ) );
-    return createResultValue( result, ${handleName}, VULKAN_HPP_NAMESPACE_STRING "::${className}${classSeparator}${commandName}"${successCodeList} );
+    return createResultValue( result, ${dataName}, VULKAN_HPP_NAMESPACE_STRING "::${className}${classSeparator}${commandName}"${successCodeList} );
   })";
 
     return replaceWithMap(
@@ -4076,10 +4079,9 @@ std::string VulkanHppGenerator::generateCommandResultGetVectorOfHandlesSingular(
           initialSkipCount ? stripPrefix( commandData.params[initialSkipCount - 1].type.type, "Vk" ) : "" },
         { "classSeparator", commandData.handle.empty() ? "" : "::" },
         { "commandName", commandName },
+        { "dataName", stripPluralS( startLowerCase( stripPrefix( commandData.params[returnParamIndex].name, "p" ) ) ) },
+        { "dataType", dataType },
         { "nodiscard", nodiscard },
-        { "handleName",
-          stripPluralS( startLowerCase( stripPrefix( commandData.params[returnParamIndex].name, "p" ) ) ) },
-        { "handleType", handleType },
         { "returnType", returnType },
         { "successCodeList", generateSuccessCodeList( commandData.successCodes ) },
         { "vkCommand", name } } );
@@ -4514,11 +4516,11 @@ std::string VulkanHppGenerator::generateCommandResultMultiSuccessWithErrors1Retu
               return generateCommandSetStandardEnhancedWithAllocatorSingularUnique(
                 definition,
                 generateCommandStandard( name, commandData, initialSkipCount, definition ),
-                generateCommandResultGetVectorOfHandles(
+                generateCommandResultGetVectorOfHandlesOrValues(
                   name, commandData, initialSkipCount, definition, vectorParamIndices, returnParamIndex, false ),
-                generateCommandResultGetVectorOfHandles(
+                generateCommandResultGetVectorOfHandlesOrValues(
                   name, commandData, initialSkipCount, definition, vectorParamIndices, returnParamIndex, true ),
-                generateCommandResultGetVectorOfHandlesSingular(
+                generateCommandResultGetVectorOfHandlesOrValuesSingular(
                   name, commandData, initialSkipCount, definition, vectorParamIndices, returnParamIndex ),
                 generateCommandResultGetVectorOfHandlesUnique(
                   name, commandData, initialSkipCount, definition, vectorParamIndices, returnParamIndex, false ),
@@ -4839,9 +4841,9 @@ std::string VulkanHppGenerator::generateCommandResultSingleSuccessWithErrors1Ret
       return generateCommandSetStandardEnhancedWithAllocatorUnique(
         definition,
         generateCommandStandard( name, commandData, initialSkipCount, definition ),
-        generateCommandResultGetVectorOfHandles(
+        generateCommandResultGetVectorOfHandlesOrValues(
           name, commandData, initialSkipCount, definition, { vectorParamIndex }, returnParamIndex, false ),
-        generateCommandResultGetVectorOfHandles(
+        generateCommandResultGetVectorOfHandlesOrValues(
           name, commandData, initialSkipCount, definition, { vectorParamIndex }, returnParamIndex, true ),
         generateCommandResultGetVectorOfHandlesUnique(
           name, commandData, initialSkipCount, definition, { vectorParamIndex }, returnParamIndex, false ),
@@ -4871,11 +4873,11 @@ std::string VulkanHppGenerator::generateCommandResultSingleSuccessWithErrors1Ret
           return generateCommandSetStandardEnhancedWithAllocatorSingularUnique(
             definition,
             generateCommandStandard( name, commandData, initialSkipCount, definition ),
-            generateCommandResultGetVectorOfHandles(
+            generateCommandResultGetVectorOfHandlesOrValues(
               name, commandData, initialSkipCount, definition, vectorParamIndices, returnParamIndex, false ),
-            generateCommandResultGetVectorOfHandles(
+            generateCommandResultGetVectorOfHandlesOrValues(
               name, commandData, initialSkipCount, definition, vectorParamIndices, returnParamIndex, true ),
-            generateCommandResultGetVectorOfHandlesSingular(
+            generateCommandResultGetVectorOfHandlesOrValuesSingular(
               name, commandData, initialSkipCount, definition, vectorParamIndices, returnParamIndex ),
             generateCommandResultGetVectorOfHandlesUnique(
               name, commandData, initialSkipCount, definition, vectorParamIndices, returnParamIndex, false ),
@@ -4898,12 +4900,51 @@ std::string
                                                                                 size_t returnParamIndex ) const
 {
   std::map<size_t, size_t> vectorParamIndices = determineVectorParamIndices( commandData.params );
-  if ( vectorParamIndices.empty() )
+  switch ( vectorParamIndices.size() )
   {
-    return generateCommandSetStandardEnhanced(
-      definition,
-      generateCommandStandard( name, commandData, initialSkipCount, definition ),
-      generateCommandResultGetValue( name, commandData, initialSkipCount, definition, returnParamIndex ) );
+    case 0:
+      return generateCommandSetStandardEnhanced(
+        definition,
+        generateCommandStandard( name, commandData, initialSkipCount, definition ),
+        generateCommandResultGetValue( name, commandData, initialSkipCount, definition, returnParamIndex ) );
+    case 2:
+      return generateCommandResultSingleSuccessWithErrors1ReturnValue2Vectors(
+        name, commandData, initialSkipCount, definition, returnParamIndex, vectorParamIndices );
+      break;
+  }
+  return "";
+}
+
+std::string VulkanHppGenerator::generateCommandResultSingleSuccessWithErrors1ReturnValue2Vectors(
+  std::string const &              name,
+  CommandData const &              commandData,
+  size_t                           initialSkipCount,
+  bool                             definition,
+  size_t                           returnParamIndex,
+  std::map<size_t, size_t> const & vectorParamIndices ) const
+{
+  if ( returnParamIndex == std::next( vectorParamIndices.begin() )->first )
+  {
+    if ( vectorParamIndices.begin()->second == std::next( vectorParamIndices.begin() )->second )
+    {
+      if ( commandData.params[vectorParamIndices.begin()->second].type.type == "uint32_t" )
+      {
+        if ( ( commandData.params[vectorParamIndices.begin()->first].type.type != "void" ) &&
+             !isHandleType( commandData.params[vectorParamIndices.begin()->first].type.type ) &&
+             !isStructureChainAnchor( commandData.params[vectorParamIndices.begin()->first].type.type ) )
+        {
+          return generateCommandSetStandardEnhancedWithAllocatorSingular(
+            definition,
+            generateCommandStandard( name, commandData, initialSkipCount, definition ),
+            generateCommandResultGetVectorOfHandlesOrValues(
+              name, commandData, initialSkipCount, definition, vectorParamIndices, returnParamIndex, false ),
+            generateCommandResultGetVectorOfHandlesOrValues(
+              name, commandData, initialSkipCount, definition, vectorParamIndices, returnParamIndex, true ),
+            generateCommandResultGetVectorOfHandlesOrValuesSingular(
+              name, commandData, initialSkipCount, definition, vectorParamIndices, returnParamIndex ) );
+        }
+      }
+    }
   }
   return "";
 }
@@ -5223,6 +5264,31 @@ ${commandEnhancedWithAllocator}
                                           { "newlineOnDefinition", definition ? "\n" : "" } } ) );
 }
 
+std::string VulkanHppGenerator::generateCommandSetStandardEnhancedWithAllocatorSingular(
+  bool                definition,
+  std::string const & standard,
+  std::string const & enhanced,
+  std::string const & enhancedWithAllocator,
+  std::string const & enhancedSingular ) const
+{
+  std::string const commandTemplate = R"(
+${commandStandard}${newlineOnDefinition}
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+${commandEnhanced}${newlineOnDefinition}
+${commandEnhancedWithAllocator}${newlineOnDefinition}
+${commandEnhancedSingular}${newlineOnDefinition}
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+)";
+
+  return replaceWithMap(
+    commandTemplate,
+    std::map<std::string, std::string>( { { "commandEnhanced", enhanced },
+                                          { "commandEnhancedSingular", enhancedSingular },
+                                          { "commandEnhancedWithAllocator", enhancedWithAllocator },
+                                          { "commandStandard", standard },
+                                          { "newlineOnDefinition", definition ? "\n" : "" } } ) );
+}
+
 std::string VulkanHppGenerator::generateCommandSetStandardEnhancedWithAllocatorSingularUnique(
   bool                definition,
   std::string const & standard,
@@ -8333,10 +8399,32 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandResultSingleSuccessWith
   else if ( commandIt->second.params[returnParamIndex].type.type != "void" )
   {
     std::map<size_t, size_t> vectorParamIndices = determineVectorParamIndices( commandIt->second.params );
-    if ( vectorParamIndices.empty() )
+    switch ( vectorParamIndices.size() )
     {
-      str = generateRAIIHandleCommandResultSingleSuccessWithErrors1ReturnValue(
-        commandIt, initialSkipCount, vectorParamIndices, { returnParamIndex }, definition );
+      case 0:
+        str = generateRAIIHandleCommandResultSingleSuccessWithErrors1ReturnValue(
+          commandIt, initialSkipCount, vectorParamIndices, { returnParamIndex }, definition );
+        break;
+      case 2:
+        if ( returnParamIndex == std::next( vectorParamIndices.begin() )->first )
+        {
+          if ( vectorParamIndices.begin()->second == std::next( vectorParamIndices.begin() )->second )
+          {
+            if ( commandIt->second.params[vectorParamIndices.begin()->second].type.type == "uint32_t" )
+            {
+              if ( ( commandIt->second.params[vectorParamIndices.begin()->first].type.type != "void" ) &&
+                   !isHandleType( commandIt->second.params[vectorParamIndices.begin()->first].type.type ) &&
+                   !isStructureChainAnchor( commandIt->second.params[vectorParamIndices.begin()->first].type.type ) )
+              {
+                str = generateRAIIHandleCommandResultSingleSuccessWithErrors1ReturnValueVector(
+                  commandIt, initialSkipCount, returnParamIndex, vectorParamIndices, definition );
+                str += generateRAIIHandleCommandResultSingleSuccessWithErrors1ReturnValueSingular(
+                  commandIt, initialSkipCount, returnParamIndex, vectorParamIndices, definition );
+              }
+            }
+          }
+        }
+        break;
     }
   }
   else
@@ -8456,6 +8544,136 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandResultSingleSuccessWith
   }
 }
 
+std::string VulkanHppGenerator::generateRAIIHandleCommandResultSingleSuccessWithErrors1ReturnValueSingular(
+  std::map<std::string, CommandData>::const_iterator commandIt,
+  size_t                                             initialSkipCount,
+  size_t                                             returnParamIndex,
+  std::map<size_t, size_t> const &                   vectorParamIndices,
+  bool                                               definition ) const
+{
+  assert( vectorParamIndices.size() == 2 );
+  assert( returnParamIndex == std::next( vectorParamIndices.begin() )->first );
+  assert( vectorParamIndices.begin()->second == std::next( vectorParamIndices.begin() )->second );
+
+  std::set<size_t> skippedParameters = determineSkippedParams(
+    commandIt->second.params, initialSkipCount, vectorParamIndices, { returnParamIndex }, true );
+  std::set<size_t> singularParams = determineSingularParams( returnParamIndex, vectorParamIndices );
+  std::string      argumentList   = generateArgumentListEnhanced(
+    commandIt->second.params, skippedParameters, singularParams, definition, false, false, false );
+  std::string commandName =
+    stripPluralS( generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags ) );
+  assert( beginsWith( commandIt->second.params[returnParamIndex].type.type, "Vk" ) );
+  std::string dataType =
+    "VULKAN_HPP_NAMESPACE::" + stripPrefix( commandIt->second.params[returnParamIndex].type.type, "Vk" );
+
+  if ( definition )
+  {
+    std::string const singularDefinitionTemplate =
+      R"(
+  VULKAN_HPP_NODISCARD ${dataType} ${className}::${commandName}( ${argumentList} ) const
+  {
+    ${dataType} ${dataName};
+    Result result = static_cast<Result>( getDispatcher()->${vkCommand}( ${callArguments} ) );
+    if ( ${failureCheck} )
+    {
+      throwResultException( result, VULKAN_HPP_NAMESPACE_STRING"::${className}::${commandName}" );
+    }
+    return ${dataName};
+  }
+)";
+
+    return replaceWithMap(
+      singularDefinitionTemplate,
+      { { "argumentList", argumentList },
+        { "callArguments", generateCallArgumentsEnhanced( commandIt->second.params, initialSkipCount, false, singularParams, true ) },
+        { "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) },
+        { "commandName", commandName },
+        { "dataName", stripPluralS( startLowerCase( stripPrefix( commandIt->second.params[returnParamIndex].name, "p" ) ) ) },
+          { "dataType", dataType },
+        { "failureCheck", generateFailureCheck( commandIt->second.successCodes ) },
+        { "vkCommand", commandIt->first } } );
+  }
+  else
+  {
+    std::string const singularDeclarationTemplate =
+      R"(
+    VULKAN_HPP_NODISCARD ${dataType} ${commandName}( ${argumentList} ) const;
+)";
+
+    return replaceWithMap( singularDeclarationTemplate,
+                           {
+                             { "argumentList", argumentList },
+                             { "commandName", commandName },
+                             { "dataType", dataType }
+                           } );
+  }
+}
+
+std::string VulkanHppGenerator::generateRAIIHandleCommandResultSingleSuccessWithErrors1ReturnValueVector(
+  std::map<std::string, CommandData>::const_iterator commandIt,
+  size_t                                             initialSkipCount,
+  size_t                                             returnParamIndex,
+  std::map<size_t, size_t> const &                   vectorParamIndices,
+  bool                                               definition ) const
+{
+  assert( vectorParamIndices.size() == 2 );
+  assert( returnParamIndex == std::next( vectorParamIndices.begin() )->first );
+  assert( vectorParamIndices.begin()->second == std::next( vectorParamIndices.begin() )->second );
+
+  std::set<size_t> skippedParameters = determineSkippedParams(
+    commandIt->second.params, initialSkipCount, vectorParamIndices, { returnParamIndex }, false );
+  std::string argumentList =
+    generateArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, definition, false, false, false );
+  std::string commandName = generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags );
+  assert( beginsWith( commandIt->second.params[returnParamIndex].type.type, "Vk" ) );
+  std::string elementType =
+    "VULKAN_HPP_NAMESPACE::" + stripPrefix( commandIt->second.params[returnParamIndex].type.type, "Vk" );
+
+  if ( definition )
+  {
+    std::string const definitionTemplate =
+      R"(
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<${elementType}> ${className}::${commandName}( ${argumentList} ) const
+  {${functionPointerCheck}
+    std::vector<${elementType}> ${vectorName}( ${vectorSize} );
+    Result result = static_cast<Result>( getDispatcher()->${vkCommand}( ${callArguments} ) );
+    if ( ${failureCheck} )
+    {
+      throwResultException( result, VULKAN_HPP_NAMESPACE_STRING"::${className}::${commandName}" );
+    }
+    return ${vectorName};
+  }
+)";
+
+    return replaceWithMap(
+      definitionTemplate,
+      { { "argumentList", argumentList },
+        { "callArguments",
+          generateCallArgumentsEnhanced( commandIt->second.params, initialSkipCount, false, {}, true ) },
+        { "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) },
+        { "commandName", commandName },
+        { "elementType", elementType },
+        { "failureCheck", generateFailureCheck( commandIt->second.successCodes ) },
+        { "functionPointerCheck", generateFunctionPointerCheck( commandIt->first, commandIt->second.referencedIn ) },
+        { "vectorName", startLowerCase( stripPrefix( commandIt->second.params[returnParamIndex].name, "p" ) ) },
+        { "vectorSize",
+          startLowerCase( stripPrefix( commandIt->second.params[vectorParamIndices.begin()->first].name, "p" ) ) +
+            ".size()" },
+        { "vkCommand", commandIt->first } } );
+  }
+  else
+  {
+    std::string const declarationTemplate =
+      R"(
+    VULKAN_HPP_NODISCARD std::vector<${elementType}> ${commandName}( ${argumentList} ) const;
+)";
+
+    return replaceWithMap(
+      declarationTemplate,
+      { { "argumentList", argumentList }, { "commandName", commandName }, { "elementType", elementType } } );
+  }
+}
+
 std::string VulkanHppGenerator::generateRAIIHandleCommandResultSingleSuccessWithErrors1ReturnVoidSingular(
   std::map<std::string, CommandData>::const_iterator commandIt,
   size_t                                             initialSkipCount,
@@ -17045,8 +17263,8 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h
     tinyxml2::XMLError error = doc.LoadFile( filename.c_str() );
     if ( error != tinyxml2::XML_SUCCESS )
     {
-      std::cout << "VulkanHppGenerator: failed to load file " << filename << " with error <" << toString( error )
-                << ">" << std::endl;
+      std::cout << "VulkanHppGenerator: failed to load file " << filename << " with error <" << toString( error ) << ">"
+                << std::endl;
       return -1;
     }
 
diff --git a/VulkanHppGenerator.hpp b/VulkanHppGenerator.hpp
index 13a5f9c..0557ab4 100644
--- a/VulkanHppGenerator.hpp
+++ b/VulkanHppGenerator.hpp
@@ -532,19 +532,20 @@ private:
                                                         bool                             definition,
                                                         std::map<size_t, size_t> const & vectorParamIndices,
                                                         size_t                           returnParamIndex ) const;
-  std::string generateCommandResultGetVectorOfHandles( std::string const &              name,
-                                                       CommandData const &              commandData,
-                                                       size_t                           initialSkipCount,
-                                                       bool                             definition,
-                                                       std::map<size_t, size_t> const & vectorParamIndices,
-                                                       size_t                           returnParamIndex,
-                                                       bool                             withAllocator ) const;
-  std::string generateCommandResultGetVectorOfHandlesSingular( std::string const &              name,
+  std::string generateCommandResultGetVectorOfHandlesOrValues( std::string const &              name,
                                                                CommandData const &              commandData,
                                                                size_t                           initialSkipCount,
                                                                bool                             definition,
                                                                std::map<size_t, size_t> const & vectorParamIndices,
-                                                               size_t returnParamIndex ) const;
+                                                               size_t                           returnParamIndex,
+                                                               bool                             withAllocator ) const;
+  std::string
+              generateCommandResultGetVectorOfHandlesOrValuesSingular( std::string const &              name,
+                                                                       CommandData const &              commandData,
+                                                                       size_t                           initialSkipCount,
+                                                                       bool                             definition,
+                                                                       std::map<size_t, size_t> const & vectorParamIndices,
+                                                                       size_t                           returnParamIndex ) const;
   std::string generateCommandResultGetVectorOfHandlesUnique( std::string const &              name,
                                                              CommandData const &              commandData,
                                                              size_t                           initialSkipCount,
@@ -645,6 +646,13 @@ private:
                                                                         size_t              initialSkipCount,
                                                                         bool                definition,
                                                                         size_t              returnParamIndex ) const;
+  std::string generateCommandResultSingleSuccessWithErrors1ReturnValue2Vectors(
+    std::string const &              name,
+    CommandData const &              commandData,
+    size_t                           initialSkipCount,
+    bool                             definition,
+    size_t                           returnParamIndex,
+    std::map<size_t, size_t> const & vectorParamIndices ) const;
   std::string generateCommandResultSingleSuccessWithErrors1ReturnVoid( std::string const & name,
                                                                        CommandData const & commandData,
                                                                        size_t              initialSkipCount,
@@ -692,12 +700,17 @@ private:
                                                                        std::string const & enhancedWithAllocator,
                                                                        std::string const & enhancedSingular ) const;
   std::string
-    generateCommandSetStandardEnhancedWithAllocatorDeprecated2( bool                definition,
-                                                                std::string const & standard,
-                                                                std::string const & enhancedDeprecated,
-                                                                std::string const & enhancedWithAllocatorDeprecated,
-                                                                std::string const & enhanced,
-                                                                std::string const & enhancedWithAllocator ) const;
+              generateCommandSetStandardEnhancedWithAllocatorDeprecated2( bool                definition,
+                                                                          std::string const & standard,
+                                                                          std::string const & enhancedDeprecated,
+                                                                          std::string const & enhancedWithAllocatorDeprecated,
+                                                                          std::string const & enhanced,
+                                                                          std::string const & enhancedWithAllocator ) const;
+  std::string generateCommandSetStandardEnhancedWithAllocatorSingular( bool                definition,
+                                                                       std::string const & standard,
+                                                                       std::string const & enhanced,
+                                                                       std::string const & enhancedWithAllocator,
+                                                                       std::string const & enhancedSingular ) const;
   std::string
     generateCommandSetStandardEnhancedWithAllocatorSingularUnique( bool                definition,
                                                                    std::string const & standard,
@@ -973,6 +986,18 @@ private:
     std::map<size_t, size_t> const &                   vectorParamIndices,
     std::vector<size_t> const &                        nonConstPointerParamIndices,
     bool                                               definition ) const;
+  std::string generateRAIIHandleCommandResultSingleSuccessWithErrors1ReturnValueSingular(
+    std::map<std::string, CommandData>::const_iterator commandIt,
+    size_t                                             initialSkipCount,
+    size_t                                             returnParamIndex,
+    std::map<size_t, size_t> const &                   vectorParamIndices,
+    bool                                               definition ) const;
+  std::string generateRAIIHandleCommandResultSingleSuccessWithErrors1ReturnValueVector(
+    std::map<std::string, CommandData>::const_iterator commandIt,
+    size_t                                             initialSkipCount,
+    size_t                                             returnParamIndex,
+    std::map<size_t, size_t> const &                   vectorParamIndices,
+    bool                                               definition ) const;
   std::string generateRAIIHandleCommandResultSingleSuccessWithErrors1ReturnVoidSingular(
     std::map<std::string, CommandData>::const_iterator commandIt,
     size_t                                             initialSkipCount,
diff --git a/vulkan/vulkan_funcs.hpp b/vulkan/vulkan_funcs.hpp
index 4458f58..1de2e29 100644
--- a/vulkan/vulkan_funcs.hpp
+++ b/vulkan/vulkan_funcs.hpp
@@ -2818,7 +2818,7 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename PipelineAllocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<Pipeline, PipelineAllocator>>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
                                          Device::createGraphicsPipelines(
       VULKAN_HPP_NAMESPACE::PipelineCache                                        pipelineCache,
       ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
@@ -2826,8 +2826,8 @@ namespace VULKAN_HPP_NAMESPACE
       Dispatch const &                                                           d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
-    std::vector<Pipeline, PipelineAllocator> pipelines( createInfos.size() );
-    Result                                   result = static_cast<Result>(
+    std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator> pipelines( createInfos.size() );
+    Result                                                         result = static_cast<Result>(
       d.vkCreateGraphicsPipelines( m_device,
                                    static_cast<VkPipelineCache>( pipelineCache ),
                                    createInfos.size(),
@@ -2846,7 +2846,7 @@ namespace VULKAN_HPP_NAMESPACE
             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>>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
                                          Device::createGraphicsPipelines(
       VULKAN_HPP_NAMESPACE::PipelineCache                                        pipelineCache,
       ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
@@ -2855,8 +2855,8 @@ namespace VULKAN_HPP_NAMESPACE
       Dispatch const &                                                           d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
-    std::vector<Pipeline, PipelineAllocator> pipelines( createInfos.size(), pipelineAllocator );
-    Result                                   result = static_cast<Result>(
+    std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator> pipelines( createInfos.size(), pipelineAllocator );
+    Result                                                         result = static_cast<Result>(
       d.vkCreateGraphicsPipelines( m_device,
                                    static_cast<VkPipelineCache>( pipelineCache ),
                                    createInfos.size(),
@@ -2872,15 +2872,15 @@ namespace VULKAN_HPP_NAMESPACE
   }
 
   template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<Pipeline>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<VULKAN_HPP_NAMESPACE::Pipeline>
     Device::createGraphicsPipeline( VULKAN_HPP_NAMESPACE::PipelineCache                      pipelineCache,
                                     const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo & createInfo,
                                     Optional<const AllocationCallbacks>                      allocator,
                                     Dispatch const &                                         d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
-    Pipeline pipeline;
-    Result   result = static_cast<Result>(
+    VULKAN_HPP_NAMESPACE::Pipeline pipeline;
+    Result                         result = static_cast<Result>(
       d.vkCreateGraphicsPipelines( m_device,
                                    static_cast<VkPipelineCache>( pipelineCache ),
                                    1,
@@ -3022,7 +3022,7 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename PipelineAllocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<Pipeline, PipelineAllocator>>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
                                          Device::createComputePipelines(
       VULKAN_HPP_NAMESPACE::PipelineCache                                       pipelineCache,
       ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos,
@@ -3030,8 +3030,8 @@ namespace VULKAN_HPP_NAMESPACE
       Dispatch const &                                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
-    std::vector<Pipeline, PipelineAllocator> pipelines( createInfos.size() );
-    Result                                   result = static_cast<Result>(
+    std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator> pipelines( createInfos.size() );
+    Result                                                         result = static_cast<Result>(
       d.vkCreateComputePipelines( m_device,
                                   static_cast<VkPipelineCache>( pipelineCache ),
                                   createInfos.size(),
@@ -3050,7 +3050,7 @@ namespace VULKAN_HPP_NAMESPACE
             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>>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
                                          Device::createComputePipelines(
       VULKAN_HPP_NAMESPACE::PipelineCache                                       pipelineCache,
       ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos,
@@ -3059,8 +3059,8 @@ namespace VULKAN_HPP_NAMESPACE
       Dispatch const &                                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
-    std::vector<Pipeline, PipelineAllocator> pipelines( createInfos.size(), pipelineAllocator );
-    Result                                   result = static_cast<Result>(
+    std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator> pipelines( createInfos.size(), pipelineAllocator );
+    Result                                                         result = static_cast<Result>(
       d.vkCreateComputePipelines( m_device,
                                   static_cast<VkPipelineCache>( pipelineCache ),
                                   createInfos.size(),
@@ -3076,15 +3076,15 @@ namespace VULKAN_HPP_NAMESPACE
   }
 
   template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<Pipeline>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<VULKAN_HPP_NAMESPACE::Pipeline>
     Device::createComputePipeline( VULKAN_HPP_NAMESPACE::PipelineCache                     pipelineCache,
                                    const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo & createInfo,
                                    Optional<const AllocationCallbacks>                     allocator,
                                    Dispatch const &                                        d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
-    Pipeline pipeline;
-    Result   result = static_cast<Result>(
+    VULKAN_HPP_NAMESPACE::Pipeline pipeline;
+    Result                         result = static_cast<Result>(
       d.vkCreateComputePipelines( m_device,
                                   static_cast<VkPipelineCache>( pipelineCache ),
                                   1,
@@ -3720,12 +3720,13 @@ namespace VULKAN_HPP_NAMESPACE
 #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
+    typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DescriptorSet, DescriptorSetAllocator>>::type
     Device::allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
-    std::vector<DescriptorSet, DescriptorSetAllocator> descriptorSets( allocateInfo.descriptorSetCount );
-    Result                                             result = static_cast<Result>(
+    std::vector<VULKAN_HPP_NAMESPACE::DescriptorSet, DescriptorSetAllocator> descriptorSets(
+      allocateInfo.descriptorSetCount );
+    Result result = static_cast<Result>(
       d.vkAllocateDescriptorSets( m_device,
                                   reinterpret_cast<const VkDescriptorSetAllocateInfo *>( &allocateInfo ),
                                   reinterpret_cast<VkDescriptorSet *>( descriptorSets.data() ) ) );
@@ -3737,15 +3738,15 @@ namespace VULKAN_HPP_NAMESPACE
             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
+    typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DescriptorSet, DescriptorSetAllocator>>::type
     Device::allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo,
                                     DescriptorSetAllocator &          descriptorSetAllocator,
                                     Dispatch const &                  d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
-    std::vector<DescriptorSet, DescriptorSetAllocator> descriptorSets( allocateInfo.descriptorSetCount,
-                                                                       descriptorSetAllocator );
-    Result                                             result = static_cast<Result>(
+    std::vector<VULKAN_HPP_NAMESPACE::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() ) ) );
@@ -4289,12 +4290,13 @@ namespace VULKAN_HPP_NAMESPACE
 #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
+    typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CommandBuffer, CommandBufferAllocator>>::type
     Device::allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
-    std::vector<CommandBuffer, CommandBufferAllocator> commandBuffers( allocateInfo.commandBufferCount );
-    Result                                             result = static_cast<Result>(
+    std::vector<VULKAN_HPP_NAMESPACE::CommandBuffer, CommandBufferAllocator> commandBuffers(
+      allocateInfo.commandBufferCount );
+    Result result = static_cast<Result>(
       d.vkAllocateCommandBuffers( m_device,
                                   reinterpret_cast<const VkCommandBufferAllocateInfo *>( &allocateInfo ),
                                   reinterpret_cast<VkCommandBuffer *>( commandBuffers.data() ) ) );
@@ -4306,15 +4308,15 @@ namespace VULKAN_HPP_NAMESPACE
             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
+    typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CommandBuffer, CommandBufferAllocator>>::type
     Device::allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo,
                                     CommandBufferAllocator &          commandBufferAllocator,
                                     Dispatch const &                  d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
-    std::vector<CommandBuffer, CommandBufferAllocator> commandBuffers( allocateInfo.commandBufferCount,
-                                                                       commandBufferAllocator );
-    Result                                             result = static_cast<Result>(
+    std::vector<VULKAN_HPP_NAMESPACE::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() ) ) );
@@ -8072,15 +8074,15 @@ namespace VULKAN_HPP_NAMESPACE
 #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
+    typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SwapchainKHR, SwapchainKHRAllocator>>::type
     Device::createSharedSwapchainsKHR(
       ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
       Optional<const AllocationCallbacks>                                    allocator,
       Dispatch const &                                                       d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
-    std::vector<SwapchainKHR, SwapchainKHRAllocator> swapchains( createInfos.size() );
-    Result                                           result = static_cast<Result>(
+    std::vector<VULKAN_HPP_NAMESPACE::SwapchainKHR, SwapchainKHRAllocator> swapchains( createInfos.size() );
+    Result                                                                 result = static_cast<Result>(
       d.vkCreateSharedSwapchainsKHR( m_device,
                                      createInfos.size(),
                                      reinterpret_cast<const VkSwapchainCreateInfoKHR *>( createInfos.data() ),
@@ -8095,7 +8097,7 @@ namespace VULKAN_HPP_NAMESPACE
             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
+    typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SwapchainKHR, SwapchainKHRAllocator>>::type
     Device::createSharedSwapchainsKHR(
       ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
       Optional<const AllocationCallbacks>                                    allocator,
@@ -8103,8 +8105,9 @@ namespace VULKAN_HPP_NAMESPACE
       Dispatch const &                                                       d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
-    std::vector<SwapchainKHR, SwapchainKHRAllocator> swapchains( createInfos.size(), swapchainKHRAllocator );
-    Result                                           result = static_cast<Result>(
+    std::vector<VULKAN_HPP_NAMESPACE::SwapchainKHR, SwapchainKHRAllocator> swapchains( createInfos.size(),
+                                                                                       swapchainKHRAllocator );
+    Result                                                                 result = static_cast<Result>(
       d.vkCreateSharedSwapchainsKHR( m_device,
                                      createInfos.size(),
                                      reinterpret_cast<const VkSwapchainCreateInfoKHR *>( createInfos.data() ),
@@ -8115,14 +8118,15 @@ namespace VULKAN_HPP_NAMESPACE
   }
 
   template <typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<SwapchainKHR>::type
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::SwapchainKHR>::type
     Device::createSharedSwapchainKHR( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR & createInfo,
                                       Optional<const AllocationCallbacks>                  allocator,
                                       Dispatch const &                                     d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
-    SwapchainKHR swapchain;
-    Result       result = static_cast<Result>(
+    VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain;
+    Result                             result = static_cast<Result>(
       d.vkCreateSharedSwapchainsKHR( m_device,
                                      1,
                                      reinterpret_cast<const VkSwapchainCreateInfoKHR *>( &createInfo ),
@@ -14868,7 +14872,7 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename PipelineAllocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<Pipeline, PipelineAllocator>>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
                                          Device::createRayTracingPipelinesNV(
       VULKAN_HPP_NAMESPACE::PipelineCache                                            pipelineCache,
       ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
@@ -14876,8 +14880,8 @@ namespace VULKAN_HPP_NAMESPACE
       Dispatch const &                                                               d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
-    std::vector<Pipeline, PipelineAllocator> pipelines( createInfos.size() );
-    Result                                   result = static_cast<Result>(
+    std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator> pipelines( createInfos.size() );
+    Result                                                         result = static_cast<Result>(
       d.vkCreateRayTracingPipelinesNV( m_device,
                                        static_cast<VkPipelineCache>( pipelineCache ),
                                        createInfos.size(),
@@ -14896,7 +14900,7 @@ namespace VULKAN_HPP_NAMESPACE
             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>>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
                                          Device::createRayTracingPipelinesNV(
       VULKAN_HPP_NAMESPACE::PipelineCache                                            pipelineCache,
       ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
@@ -14905,8 +14909,8 @@ namespace VULKAN_HPP_NAMESPACE
       Dispatch const &                                                               d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
-    std::vector<Pipeline, PipelineAllocator> pipelines( createInfos.size(), pipelineAllocator );
-    Result                                   result = static_cast<Result>(
+    std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator> pipelines( createInfos.size(), pipelineAllocator );
+    Result                                                         result = static_cast<Result>(
       d.vkCreateRayTracingPipelinesNV( m_device,
                                        static_cast<VkPipelineCache>( pipelineCache ),
                                        createInfos.size(),
@@ -14922,15 +14926,15 @@ namespace VULKAN_HPP_NAMESPACE
   }
 
   template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<Pipeline>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<VULKAN_HPP_NAMESPACE::Pipeline>
     Device::createRayTracingPipelineNV( VULKAN_HPP_NAMESPACE::PipelineCache                          pipelineCache,
                                         const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV & createInfo,
                                         Optional<const AllocationCallbacks>                          allocator,
                                         Dispatch const &                                             d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
-    Pipeline pipeline;
-    Result   result = static_cast<Result>(
+    VULKAN_HPP_NAMESPACE::Pipeline pipeline;
+    Result                         result = static_cast<Result>(
       d.vkCreateRayTracingPipelinesNV( m_device,
                                        static_cast<VkPipelineCache>( pipelineCache ),
                                        1,
@@ -18555,7 +18559,7 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename PipelineAllocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<Pipeline, PipelineAllocator>>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
                                          Device::createRayTracingPipelinesKHR(
       VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                      deferredOperation,
       VULKAN_HPP_NAMESPACE::PipelineCache                                             pipelineCache,
@@ -18564,8 +18568,8 @@ namespace VULKAN_HPP_NAMESPACE
       Dispatch const &                                                                d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
-    std::vector<Pipeline, PipelineAllocator> pipelines( createInfos.size() );
-    Result                                   result = static_cast<Result>( d.vkCreateRayTracingPipelinesKHR(
+    std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator> pipelines( createInfos.size() );
+    Result result = static_cast<Result>( d.vkCreateRayTracingPipelinesKHR(
       m_device,
       static_cast<VkDeferredOperationKHR>( deferredOperation ),
       static_cast<VkPipelineCache>( pipelineCache ),
@@ -18587,7 +18591,7 @@ namespace VULKAN_HPP_NAMESPACE
             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>>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
                                          Device::createRayTracingPipelinesKHR(
       VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                      deferredOperation,
       VULKAN_HPP_NAMESPACE::PipelineCache                                             pipelineCache,
@@ -18597,8 +18601,8 @@ namespace VULKAN_HPP_NAMESPACE
       Dispatch const &                                                                d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
-    std::vector<Pipeline, PipelineAllocator> pipelines( createInfos.size(), pipelineAllocator );
-    Result                                   result = static_cast<Result>( d.vkCreateRayTracingPipelinesKHR(
+    std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator> pipelines( createInfos.size(), pipelineAllocator );
+    Result result = static_cast<Result>( d.vkCreateRayTracingPipelinesKHR(
       m_device,
       static_cast<VkDeferredOperationKHR>( deferredOperation ),
       static_cast<VkPipelineCache>( pipelineCache ),
@@ -18617,7 +18621,7 @@ namespace VULKAN_HPP_NAMESPACE
   }
 
   template <typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<Pipeline>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<VULKAN_HPP_NAMESPACE::Pipeline>
     Device::createRayTracingPipelineKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
                                          VULKAN_HPP_NAMESPACE::PipelineCache        pipelineCache,
                                          const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR & createInfo,
@@ -18625,8 +18629,8 @@ namespace VULKAN_HPP_NAMESPACE
                                          Dispatch const &                                              d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
-    Pipeline pipeline;
-    Result   result = static_cast<Result>(
+    VULKAN_HPP_NAMESPACE::Pipeline pipeline;
+    Result                         result = static_cast<Result>(
       d.vkCreateRayTracingPipelinesKHR( m_device,
                                         static_cast<VkDeferredOperationKHR>( deferredOperation ),
                                         static_cast<VkPipelineCache>( pipelineCache ),
diff --git a/vulkan/vulkan_handles.hpp b/vulkan/vulkan_handles.hpp
index 4b2b86f..0b8cb48 100644
--- a/vulkan/vulkan_handles.hpp
+++ b/vulkan/vulkan_handles.hpp
@@ -8220,23 +8220,24 @@ namespace VULKAN_HPP_NAMESPACE
 #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;
+    VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::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>>
+    VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::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_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Pipeline> createGraphicsPipeline(
       VULKAN_HPP_NAMESPACE::PipelineCache                      pipelineCache,
       const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo & createInfo,
       Optional<const AllocationCallbacks> allocator            VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
@@ -8282,23 +8283,24 @@ namespace VULKAN_HPP_NAMESPACE
 #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>> createComputePipelines(
-      VULKAN_HPP_NAMESPACE::PipelineCache                                       pipelineCache,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos,
-      Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-      Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
+                         createComputePipelines( VULKAN_HPP_NAMESPACE::PipelineCache                                       pipelineCache,
+                                                 ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> 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>>
+    VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
                          createComputePipelines( VULKAN_HPP_NAMESPACE::PipelineCache                                       pipelineCache,
                                                  ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> 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> createComputePipeline(
+    VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Pipeline> createComputePipeline(
       VULKAN_HPP_NAMESPACE::PipelineCache                     pipelineCache,
       const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo & createInfo,
       Optional<const AllocationCallbacks> allocator           VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
@@ -8563,7 +8565,7 @@ namespace VULKAN_HPP_NAMESPACE
     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
+      typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DescriptorSet, DescriptorSetAllocator>>::type
       allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo,
                               Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename DescriptorSetAllocator = std::allocator<DescriptorSet>,
@@ -8571,7 +8573,7 @@ namespace VULKAN_HPP_NAMESPACE
               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
+      typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DescriptorSet, DescriptorSetAllocator>>::type
       allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo,
                               DescriptorSetAllocator &          descriptorSetAllocator,
                               Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
@@ -8808,7 +8810,7 @@ namespace VULKAN_HPP_NAMESPACE
     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
+      typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CommandBuffer, CommandBufferAllocator>>::type
       allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo,
                               Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename CommandBufferAllocator = std::allocator<CommandBuffer>,
@@ -8816,7 +8818,7 @@ namespace VULKAN_HPP_NAMESPACE
               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
+      typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CommandBuffer, CommandBufferAllocator>>::type
       allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo,
                               CommandBufferAllocator &          commandBufferAllocator,
                               Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
@@ -9334,7 +9336,7 @@ namespace VULKAN_HPP_NAMESPACE
     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
+      typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SwapchainKHR, SwapchainKHRAllocator>>::type
       createSharedSwapchainsKHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
                                  Optional<const AllocationCallbacks> allocator
                                                     VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
@@ -9344,16 +9346,17 @@ namespace VULKAN_HPP_NAMESPACE
               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
+      typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::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;
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::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>>>
@@ -10700,23 +10703,25 @@ namespace VULKAN_HPP_NAMESPACE
 #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;
+    VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::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;
+    VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::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_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Pipeline> createRayTracingPipelineNV(
       VULKAN_HPP_NAMESPACE::PipelineCache                          pipelineCache,
       const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV & createInfo,
       Optional<const AllocationCallbacks> allocator                VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
@@ -11449,25 +11454,27 @@ namespace VULKAN_HPP_NAMESPACE
 #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>> createRayTracingPipelinesKHR(
-      VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                      deferredOperation,
-      VULKAN_HPP_NAMESPACE::PipelineCache                                             pipelineCache,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos,
-      Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-      Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
+                         createRayTracingPipelinesKHR(
+                           VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                      deferredOperation,
+                           VULKAN_HPP_NAMESPACE::PipelineCache                                             pipelineCache,
+                           ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> 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>> createRayTracingPipelinesKHR(
-      VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                      deferredOperation,
-      VULKAN_HPP_NAMESPACE::PipelineCache                                             pipelineCache,
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos,
-      Optional<const AllocationCallbacks>                                             allocator,
-      PipelineAllocator &                                                             pipelineAllocator,
-      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
+                         createRayTracingPipelinesKHR(
+                           VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                      deferredOperation,
+                           VULKAN_HPP_NAMESPACE::PipelineCache                                             pipelineCache,
+                           ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> 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> createRayTracingPipelineKHR(
+    VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Pipeline> createRayTracingPipelineKHR(
       VULKAN_HPP_NAMESPACE::DeferredOperationKHR                    deferredOperation,
       VULKAN_HPP_NAMESPACE::PipelineCache                           pipelineCache,
       const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR & createInfo,