diff --git a/VulkanHppGenerator.cpp b/VulkanHppGenerator.cpp
index 988778c..aa78467 100644
--- a/VulkanHppGenerator.cpp
+++ b/VulkanHppGenerator.cpp
@@ -1224,7 +1224,7 @@ void VulkanHppGenerator::appendCommand( std::string &       str,
                                         bool                definition ) const
 {
   bool                     appendedFunction            = false;
-  std::map<size_t, size_t> vectorParamIndices          = determineVectorParamIndices( commandData.params );
+  std::map<size_t, size_t> vectorParamIndices          = determineVectorParamIndicesNew( commandData.params );
   std::vector<size_t>      nonConstPointerParamIndices = determineNonConstPointerParamIndices( commandData.params );
   if ( nonConstPointerParamIndices.empty() )
   {
@@ -1288,14 +1288,24 @@ void VulkanHppGenerator::appendCommand( std::string &       str,
       {
         // just one vector parameter
         auto vectorParamIndexIt = vectorParamIndices.begin();
-        if ( commandData.params[vectorParamIndexIt->first].type.isNonConstPointer() &&
-             ( commandData.params[vectorParamIndexIt->first].type.type == "void" ) &&
-             commandData.params[vectorParamIndexIt->second].type.isValue() )
+        if ( commandData.params[vectorParamIndexIt->second].type.isValue() )
         {
-          // the vector is a non-const pointer to void (that is, a return parameter), and the size is given by value
+          // the size of the vector parameter is given by a value -> just get that stuff
+          assert( commandData.params[vectorParamIndexIt->first].type.isNonConstPointer() );
+          assert( commandData.params[vectorParamIndexIt->first].type.type == "void" );
           appendCommandGetVector( str, name, commandData, vectorParamIndices, definition );
           appendedFunction = true;
         }
+        else if ( ( commandData.returnType == "void" ) &&
+                  !determineStructureChaining(
+                    commandData.params[vectorParamIndexIt->first].type.type, m_extendedStructs, m_structureAliases ) )
+        {
+          // the size of the vector parameter itself is a pointer -> enumerate the values
+          assert( commandData.params[vectorParamIndexIt->first].type.isNonConstPointer() );
+          assert( commandData.params[vectorParamIndexIt->first].type.type != "void" );
+          appendCommandEnumerateVoid( str, name, commandData, *vectorParamIndexIt, definition );
+          appendedFunction = true;
+        }
       }
       break;
       case 2:
@@ -1342,6 +1352,8 @@ void VulkanHppGenerator::appendCommand( std::string &       str,
 
   bool twoStep = isTwoStepAlgorithm( commandData.params );
 
+  vectorParamIndices =
+    determineVectorParamIndices( commandData.params );  // determine vector param indices the old way again
   size_t returnParamIndex = determineReturnParamIndex( commandData, vectorParamIndices, twoStep );
   bool   isStructureChain =
     ( returnParamIndex != INVALID_INDEX ) &&
@@ -1625,6 +1637,36 @@ ${commandEnhancedWithAllocators}
         { "newlineOnDefinition", definition ? "\n" : "" } } ) );
 }
 
+void VulkanHppGenerator::appendCommandEnumerateVoid( std::string &                     str,
+                                                     std::string const &               name,
+                                                     CommandData const &               commandData,
+                                                     std::pair<size_t, size_t> const & vectorParamIndex,
+                                                     bool                              definition ) const
+{
+  assert( commandData.returnType == "void" );
+
+  std::string enter, leave;
+  std::tie( enter, leave ) = generateProtection( commandData.feature, commandData.extensions );
+  assert( enter.empty() );
+
+  const std::string functionTemplate = R"(
+${commandStandard}${newlineOnDefinition}
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+${commandEnhanced}${newlineOnDefinition}
+${commandEnhancedWithAllocators}
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+)";
+
+  str += replaceWithMap(
+    functionTemplate,
+    std::map<std::string, std::string>(
+      { { "commandEnhanced", constructCommandEnumerateVoid( name, commandData, vectorParamIndex, definition, false ) },
+        { "commandEnhancedWithAllocators",
+          constructCommandEnumerateVoid( name, commandData, vectorParamIndex, definition, true ) },
+        { "commandStandard", constructCommandStandard( name, commandData, definition ) },
+        { "newlineOnDefinition", definition ? "\n" : "" } } ) );
+}
+
 void VulkanHppGenerator::appendCommandGetVector( std::string &                    str,
                                                  std::string const &              name,
                                                  CommandData const &              commandData,
@@ -3821,37 +3863,48 @@ std::string VulkanHppGenerator::constructArgumentListStandard( std::vector<Param
 
 std::string VulkanHppGenerator::constructCallArgument( ParamData const & param, bool enhanced ) const
 {
-  std::string argument = param.name;
-  if ( beginsWith( param.type.type, "Vk" ) )
+  std::string argument;
+  if ( enhanced && param.len == "null-terminated" )
   {
-    if ( !param.arraySizes.empty() )
+    assert( !param.type.isValue() );
+    assert( param.type.type == "char" );
+    assert( beginsWith( param.name, "p" ) );
+    argument = startLowerCase( stripPrefix( param.name, "p" ) ) + ".c_str()";
+  }
+  else
+  {
+    argument = param.name;
+    if ( beginsWith( param.type.type, "Vk" ) )
     {
-      assert( param.arraySizes.size() == 1 );
-      assert( param.type.isValue() );
-      assert( param.type.prefix == "const" );
-      argument = "reinterpret_cast<const " + param.type.type + "*>( " + argument + " )";
-    }
-    else if ( param.type.isValue() )
-    {
-      argument = "static_cast<" + param.type.type + ">( " + argument + " )";
-    }
-    else
-    {
-      assert( !param.type.postfix.empty() );
-      if ( enhanced )
+      if ( !param.arraySizes.empty() )
       {
-        argument = startLowerCase( stripPrefix( argument, "p" ) );
-        if ( param.optional )
-        {
-          argument = "static_cast<" + param.type.compose() + ">( " + argument + " )";
-        }
-        else
-        {
-          argument = "&" + argument;
-        }
+        assert( param.arraySizes.size() == 1 );
+        assert( param.type.isValue() );
+        assert( param.type.prefix == "const" );
+        argument = "reinterpret_cast<const " + param.type.type + "*>( " + argument + " )";
+      }
+      else if ( param.type.isValue() )
+      {
+        argument = "static_cast<" + param.type.type + ">( " + argument + " )";
+      }
+      else
+      {
+        assert( !param.type.postfix.empty() );
+        if ( enhanced )
+        {
+          argument = startLowerCase( stripPrefix( argument, "p" ) );
+          if ( param.optional )
+          {
+            argument = "static_cast<" + param.type.compose() + ">( " + argument + " )";
+          }
+          else
+          {
+            argument = "&" + argument;
+          }
+        }
+        argument = "reinterpret_cast<" + ( param.type.prefix.empty() ? "" : param.type.prefix ) + " " +
+                   param.type.type + " " + param.type.postfix + ">( " + argument + " )";
       }
-      argument = "reinterpret_cast<" + ( param.type.prefix.empty() ? "" : param.type.prefix ) + " " + param.type.type +
-                 " " + param.type.postfix + ">( " + argument + " )";
     }
   }
   return argument;
@@ -3872,8 +3925,6 @@ std::string
                                                               std::map<size_t, size_t> const & vectorParamIndices,
                                                               bool                             vectorAsNullptr ) const
 {
-  assert( vectorParamIndices.size() == 2 );
-
   size_t countIndex = vectorParamIndices.begin()->second;
   assert( ( vectorParamIndices.size() != 2 ) || ( std::next( vectorParamIndices.begin() )->second == countIndex ) );
 
@@ -3894,9 +3945,20 @@ std::string
       }
       else
       {
-        arguments += "reinterpret_cast<" + params[i].type.type + " *>( enumeratedData." +
-                     ( ( vectorParamIndices.find( i ) == vectorParamIndices.begin() ) ? "first" : "second" ) +
-                     ".data() )";
+        switch ( vectorParamIndices.size() )
+        {
+          case 1:
+            assert( beginsWith( params[i].name, "p" ) );
+            arguments += "reinterpret_cast<" + params[i].type.type + " *>( " +
+                         startLowerCase( stripPrefix( params[i].name, "p" ) ) + ".data() )";
+            break;
+          case 2:
+            arguments += "reinterpret_cast<" + params[i].type.type + " *>( enumeratedData." +
+                         ( ( vectorParamIndices.find( i ) == vectorParamIndices.begin() ) ? "first" : "second" ) +
+                         ".data() )";
+            break;
+          default: assert( false );
+        }
       }
     }
     else
@@ -4056,9 +4118,8 @@ std::string
       startLowerCase( stripPrefix( commandData.params[secondVectorParamIt->first].name, "p" ) );
 
     std::string withAllocatorsTypenameCheck =
-      ", typename B1, typename B2, typename std::enable_if < std::is_same<typename B1::value_type, " +
-      templateTypeFirst + ">::value && std::is_same<typename B2::value_type, " + templateTypeSecond +
-      ">::value, int>::type ";
+      ", typename B1, typename B2, typename std::enable_if<std::is_same<typename B1::value_type, " + templateTypeFirst +
+      ">::value && std::is_same<typename B2::value_type, " + templateTypeSecond + ">::value, int>::type ";
 
     str = replaceWithMap(
       functionTemplate,
@@ -4091,7 +4152,7 @@ std::string
 
     std::string withAllocatorsTypenameCheck =
       ", typename B1 = " + templateTypeFirst + "Allocator, typename B2 = " + templateTypeSecond +
-      "Allocator, typename std::enable_if < std::is_same<typename B1::value_type, " + templateTypeFirst +
+      "Allocator, typename std::enable_if<std::is_same<typename B1::value_type, " + templateTypeFirst +
       ">::value && std::is_same<typename B2::value_type, " + templateTypeSecond + ">::value, int>::type = 0";
 
     str = replaceWithMap( functionTemplate,
@@ -4184,6 +4245,79 @@ std::string VulkanHppGenerator::constructCommandEnumerateTwoVectorsDeprecated(
   return str;
 }
 
+std::string VulkanHppGenerator::constructCommandEnumerateVoid( std::string const &               name,
+                                                               CommandData const &               commandData,
+                                                               std::pair<size_t, size_t> const & vectorParamIndex,
+                                                               bool                              definition,
+                                                               bool                              withAllocators ) const
+{
+  assert( commandData.params[0].type.type == commandData.handle );
+
+  std::string str;
+
+  std::string argumentList = constructArgumentListEnhanced(
+    commandData.params, { 0, vectorParamIndex.second, vectorParamIndex.first }, definition, withAllocators );
+  std::string commandName       = determineCommandName( name, commandData.params[0].type.type );
+  std::string vectorElementType = stripPrefix( commandData.params[vectorParamIndex.first].type.type, "Vk" );
+
+  if ( definition )
+  {
+    const std::string functionTemplate =
+      R"(  template <typename ${vectorElementType}Allocator, typename Dispatch${withAllocatorTypenameCheck}>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<${vectorElementType}, ${vectorElementType}Allocator> ${className}::${commandName}( ${argumentList} ) const
+  {
+    std::vector<${vectorElementType}, ${vectorElementType}Allocator> ${vectorName}${vectorAllocator};
+    ${counterType} ${counterName};
+    d.${vkCommand}( ${firstCallArguments} );
+    ${vectorName}.resize( ${counterName} );
+    d.${vkCommand}( ${secondCallArguments} );
+    VULKAN_HPP_ASSERT( ${counterName} <= ${vectorName}.size() );
+    return ${vectorName};
+  })";
+
+    std::string withAllocatorsTypenameCheck =
+      ", typename B, typename std::enable_if<std::is_same<typename B::value_type, " + vectorElementType +
+      ">::value, int>::type ";
+
+    str = replaceWithMap(
+      functionTemplate,
+      std::map<std::string, std::string>(
+        { { "argumentList", argumentList },
+          { "className", stripPrefix( commandData.handle, "Vk" ) },
+          { "commandName", commandName },
+          { "counterName", startLowerCase( stripPrefix( commandData.params[vectorParamIndex.second].name, "p" ) ) },
+          { "counterType", commandData.params[vectorParamIndex.second].type.type },
+          { "firstCallArguments",
+            constructCallArgumentsEnumerateVectors( commandData.params, { vectorParamIndex }, true ) },
+          { "secondCallArguments",
+            constructCallArgumentsEnumerateVectors( commandData.params, { vectorParamIndex }, false ) },
+          { "vectorAllocator", withAllocators ? ( "( " + vectorElementType + "Allocator )" ) : "" },
+          { "vectorElementType", vectorElementType },
+          { "vectorName", startLowerCase( stripPrefix( commandData.params[vectorParamIndex.first].name, "p" ) ) },
+          { "vkCommand", name },
+          { "withAllocatorTypenameCheck", withAllocators ? withAllocatorsTypenameCheck : "" } } ) );
+  }
+  else
+  {
+    const std::string functionTemplate =
+      R"(    template <typename ${vectorElementType}Allocator = std::allocator<${vectorElementType}>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE${withAllocatorTypenameCheck}>
+    VULKAN_HPP_NODISCARD std::vector<${vectorElementType}, ${vectorElementType}Allocator> ${commandName}( ${argumentList} ) const;)";
+
+    std::string withAllocatorsTypenameCheck =
+      ", typename B = " + vectorElementType +
+      "Allocator, typename std::enable_if<std::is_same<typename B::value_type, " + vectorElementType +
+      ">::value, int>::type = 0";
+
+    str = replaceWithMap( functionTemplate,
+                          std::map<std::string, std::string>(
+                            { { "argumentList", argumentList },
+                              { "commandName", commandName },
+                              { "vectorElementType", vectorElementType },
+                              { "withAllocatorTypenameCheck", withAllocators ? withAllocatorsTypenameCheck : "" } } ) );
+  }
+  return str;
+}
+
 std::string VulkanHppGenerator::constructCommandGetVector( std::string const &              name,
                                                            CommandData const &              commandData,
                                                            std::map<size_t, size_t> const & vectorParamIndices,
@@ -6362,6 +6496,36 @@ std::map<size_t, size_t> VulkanHppGenerator::determineVectorParamIndices( std::v
   return vectorParamIndices;
 }
 
+std::map<size_t, size_t>
+  VulkanHppGenerator::determineVectorParamIndicesNew( std::vector<ParamData> const & params ) const
+{
+  std::map<size_t, size_t> vectorParamIndices;
+
+  // look for the parameters whose len equals the name of an other parameter
+  for ( auto it = params.begin(); it != params.end(); ++it )
+  {
+    if ( !it->len.empty() )
+    {
+      auto findLambda = [it]( ParamData const & pd ) {
+        return pd.name == it->len;
+      };
+      auto findIt =
+        std::find_if( params.begin(), it, findLambda );  // look for a parameter named as the len of this parameter
+      assert( ( std::count_if( params.begin(), params.end(), findLambda ) == 0 ) ||
+              ( findIt < it ) );  // make sure, there is no other parameter like that
+
+      if ( findIt < it )
+      {
+        // add this parameter as a vector parameter, using the len-name parameter as the second value (or
+        // INVALID_INDEX if there is nothing like that)
+        vectorParamIndices.insert(
+          std::make_pair( std::distance( params.begin(), it ), std::distance( params.begin(), findIt ) ) );
+      }
+    }
+  }
+  return vectorParamIndices;
+}
+
 void VulkanHppGenerator::appendIndexTypeTraits( std::string & str ) const
 {
   auto indexType = m_enums.find( "VkIndexType" );
diff --git a/VulkanHppGenerator.hpp b/VulkanHppGenerator.hpp
index 7a1e6b5..84de530 100644
--- a/VulkanHppGenerator.hpp
+++ b/VulkanHppGenerator.hpp
@@ -321,6 +321,11 @@ private:
                                                 CommandData const &              commandData,
                                                 std::map<size_t, size_t> const & vectorParamIndices,
                                                 bool                             definition ) const;
+  void        appendCommandEnumerateVoid( std::string &                     str,
+                                          std::string const &               name,
+                                          CommandData const &               commandData,
+                                          std::pair<size_t, size_t> const & vectorParamIndex,
+                                          bool                              definition ) const;
   void        appendCommandGetVector( std::string &                    str,
                                       std::string const &              name,
                                       CommandData const &              commandData,
@@ -553,6 +558,11 @@ private:
                                                              std::map<size_t, size_t> const & vectorParamIndices,
                                                              bool                             definition,
                                                              bool                             withAllocators ) const;
+  std::string constructCommandEnumerateVoid( std::string const &               name,
+                                             CommandData const &               commandData,
+                                             std::pair<size_t, size_t> const & vectorParamIndex,
+                                             bool                              definition,
+                                             bool                              withAllocators ) const;
   std::string constructCommandGetVector( std::string const &              name,
                                          CommandData const &              commandData,
                                          std::map<size_t, size_t> const & vectorParamIndices,
@@ -635,6 +645,7 @@ private:
   std::vector<size_t>      determineConstPointerParamIndices( std::vector<ParamData> const & params ) const;
   std::vector<size_t>      determineNonConstPointerParamIndices( std::vector<ParamData> const & params ) const;
   std::map<size_t, size_t> determineVectorParamIndices( std::vector<ParamData> const & params ) const;
+  std::map<size_t, size_t> determineVectorParamIndicesNew( std::vector<ParamData> const & params ) const;
   std::string              generateLenInitializer(
                  std::vector<MemberData>::const_iterator                                        mit,
                  std::map<std::vector<MemberData>::const_iterator,
diff --git a/vulkan/vulkan.hpp b/vulkan/vulkan.hpp
index 0ce6e9b..ff23486 100644
--- a/vulkan/vulkan.hpp
+++ b/vulkan/vulkan.hpp
@@ -47719,21 +47719,22 @@ namespace VULKAN_HPP_NAMESPACE
 #endif
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void getCheckpointDataNV( uint32_t *                               pCheckpointDataCount,
-                              VULKAN_HPP_NAMESPACE::CheckpointDataNV * pCheckpointData,
+    void getCheckpointDataNV( uint32_t * pCheckpointDataCount,
+                              VULKAN_HPP_NAMESPACE::CheckpointDataNV * pCheckpointData
+                                                 VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<CheckpointDataNV>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    std::vector<CheckpointDataNV, Allocator>
-      getCheckpointDataNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename Allocator = std::allocator<CheckpointDataNV>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B         = Allocator,
+    template <typename CheckpointDataNVAllocator = std::allocator<CheckpointDataNV>,
+              typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD std::vector<CheckpointDataNV, CheckpointDataNVAllocator>
+                         getCheckpointDataNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <typename CheckpointDataNVAllocator = std::allocator<CheckpointDataNV>,
+              typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B                         = CheckpointDataNVAllocator,
               typename std::enable_if<std::is_same<typename B::value_type, CheckpointDataNV>::value, int>::type = 0>
-    std::vector<CheckpointDataNV, Allocator>
-      getCheckpointDataNV( Allocator const &  vectorAllocator,
-                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    VULKAN_HPP_NODISCARD std::vector<CheckpointDataNV, CheckpointDataNVAllocator>
+                         getCheckpointDataNV( CheckpointDataNVAllocator & checkpointDataAllocator,
+                                              Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -54507,71 +54508,74 @@ namespace VULKAN_HPP_NAMESPACE
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     void getImageSparseMemoryRequirements(
-      VULKAN_HPP_NAMESPACE::Image                           image,
-      uint32_t *                                            pSparseMemoryRequirementCount,
-      VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements * pSparseMemoryRequirements,
+      VULKAN_HPP_NAMESPACE::Image image,
+      uint32_t *                  pSparseMemoryRequirementCount,
+      VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements * pSparseMemoryRequirements
+                         VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<SparseImageMemoryRequirements>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    std::vector<SparseImageMemoryRequirements, Allocator>
-      getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image,
-                                        Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename Allocator                 = std::allocator<SparseImageMemoryRequirements>,
-              typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B                         = Allocator,
+    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>
-    std::vector<SparseImageMemoryRequirements, Allocator>
-      getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image,
-                                        Allocator const &           vectorAllocator,
-                                        Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+                                      int>::type              = 0>
+    VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator>
+                         getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image              image,
+                                                           SparseImageMemoryRequirementsAllocator & sparseMemoryRequirementsAllocator,
+                                                           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,
+      VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 * pSparseMemoryRequirements
+                         VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<SparseImageMemoryRequirements2>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    std::vector<SparseImageMemoryRequirements2, Allocator>
-      getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info,
-                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename Allocator                 = std::allocator<SparseImageMemoryRequirements2>,
-              typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B                         = Allocator,
+    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>
-    std::vector<SparseImageMemoryRequirements2, Allocator>
-      getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info,
-                                         Allocator const &                          vectorAllocator,
-                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+                                      int>::type               = 0>
+    VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
+                         getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info,
+                                                            SparseImageMemoryRequirements2Allocator &  sparseMemoryRequirementsAllocator,
+                                                            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,
+      VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 * pSparseMemoryRequirements
+                         VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<SparseImageMemoryRequirements2>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    std::vector<SparseImageMemoryRequirements2, Allocator>
-      getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info,
-                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
-    template <typename Allocator                 = std::allocator<SparseImageMemoryRequirements2>,
-              typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-              typename B                         = Allocator,
+    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>
-    std::vector<SparseImageMemoryRequirements2, Allocator>
-      getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info,
-                                            Allocator const &                          vectorAllocator,
-                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+                                      int>::type               = 0>
+    VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
+                         getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info,
+                                                               SparseImageMemoryRequirements2Allocator & sparseMemoryRequirementsAllocator,
+                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -60911,23 +60915,23 @@ namespace VULKAN_HPP_NAMESPACE
 #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;
+    void getQueueFamilyProperties(
+      uint32_t *                                                           pQueueFamilyPropertyCount,
+      VULKAN_HPP_NAMESPACE::QueueFamilyProperties * pQueueFamilyProperties VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
+      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<QueueFamilyProperties>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    std::vector<QueueFamilyProperties, Allocator>
-      getQueueFamilyProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    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 Allocator = std::allocator<QueueFamilyProperties>,
-      typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-      typename B         = Allocator,
+      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>
-    std::vector<QueueFamilyProperties, Allocator>
-      getQueueFamilyProperties( Allocator const &  vectorAllocator,
-                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    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>
@@ -60997,84 +61001,84 @@ namespace VULKAN_HPP_NAMESPACE
 #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;
+    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 VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
+      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<SparseImageFormatProperties>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    std::vector<SparseImageFormatProperties, Allocator>
-      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>
+    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 Allocator = std::allocator<SparseImageFormatProperties>,
-      typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-      typename B         = Allocator,
+      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>
-    std::vector<SparseImageFormatProperties, Allocator>
-      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,
-                                      Allocator const &                         vectorAllocator,
-                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    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 &    propertiesAllocator,
+                                                         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,
+      VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 * pProperties   VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<SparseImageFormatProperties2>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    std::vector<SparseImageFormatProperties2, Allocator>
-      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>
+    VULKAN_HPP_NODISCARD std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
+                         getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
+                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <
-      typename Allocator = std::allocator<SparseImageFormatProperties2>,
-      typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-      typename B         = Allocator,
+      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>
-    std::vector<SparseImageFormatProperties2, Allocator>
-      getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
-                                       Allocator const &                            vectorAllocator,
-                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    VULKAN_HPP_NODISCARD std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
+                         getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
+                                                          SparseImageFormatProperties2Allocator &      propertiesAllocator,
+                                                          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,
+      VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 * pProperties   VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<SparseImageFormatProperties2>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    std::vector<SparseImageFormatProperties2, Allocator>
-      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>
+    VULKAN_HPP_NODISCARD std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
+                         getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
+                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <
-      typename Allocator = std::allocator<SparseImageFormatProperties2>,
-      typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
-      typename B         = Allocator,
+      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>
-    std::vector<SparseImageFormatProperties2, Allocator>
-      getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
-                                          Allocator const &                            vectorAllocator,
-                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    VULKAN_HPP_NODISCARD std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
+                         getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
+                                                             SparseImageFormatProperties2Allocator &      propertiesAllocator,
+                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -97612,13 +97616,15 @@ namespace VULKAN_HPP_NAMESPACE
       pSparseMemoryRequirementCount,
       reinterpret_cast<VkSparseImageMemoryRequirements *>( pSparseMemoryRequirements ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator, typename Dispatch>
-  VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements, Allocator>
-                    Device::getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image, Dispatch const & d ) const
+  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, Allocator> sparseMemoryRequirements;
-    uint32_t                                              sparseMemoryRequirementCount;
+    std::vector<SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator> sparseMemoryRequirements;
+    uint32_t                                                                           sparseMemoryRequirementCount;
     d.vkGetImageSparseMemoryRequirements(
       m_device, static_cast<VkImage>( image ), &sparseMemoryRequirementCount, nullptr );
     sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
@@ -97627,18 +97633,25 @@ namespace VULKAN_HPP_NAMESPACE
       static_cast<VkImage>( image ),
       &sparseMemoryRequirementCount,
       reinterpret_cast<VkSparseImageMemoryRequirements *>( sparseMemoryRequirements.data() ) );
+    VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() );
     return sparseMemoryRequirements;
   }
+
   template <
-    typename Allocator,
+    typename SparseImageMemoryRequirementsAllocator,
     typename Dispatch,
     typename B,
     typename std::enable_if<std::is_same<typename B::value_type, SparseImageMemoryRequirements>::value, int>::type>
-  VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements, Allocator> Device::getImageSparseMemoryRequirements(
-    VULKAN_HPP_NAMESPACE::Image image, Allocator const & vectorAllocator, Dispatch const & d ) const
+  VULKAN_HPP_NODISCARD
+    VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator>
+                      Device::getImageSparseMemoryRequirements(
+      VULKAN_HPP_NAMESPACE::Image              image,
+      SparseImageMemoryRequirementsAllocator & sparseMemoryRequirementsAllocator,
+      Dispatch const &                         d ) const
   {
-    std::vector<SparseImageMemoryRequirements, Allocator> sparseMemoryRequirements( vectorAllocator );
-    uint32_t                                              sparseMemoryRequirementCount;
+    std::vector<SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator> sparseMemoryRequirements(
+      SparseImageMemoryRequirementsAllocator );
+    uint32_t sparseMemoryRequirementCount;
     d.vkGetImageSparseMemoryRequirements(
       m_device, static_cast<VkImage>( image ), &sparseMemoryRequirementCount, nullptr );
     sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
@@ -97647,6 +97660,7 @@ namespace VULKAN_HPP_NAMESPACE
       static_cast<VkImage>( image ),
       &sparseMemoryRequirementCount,
       reinterpret_cast<VkSparseImageMemoryRequirements *>( sparseMemoryRequirements.data() ) );
+    VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() );
     return sparseMemoryRequirements;
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@@ -97664,14 +97678,16 @@ namespace VULKAN_HPP_NAMESPACE
       pSparseMemoryRequirementCount,
       reinterpret_cast<VkSparseImageMemoryRequirements2 *>( pSparseMemoryRequirements ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator, typename Dispatch>
-  VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements2, Allocator>
-                    Device::getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info,
+  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, Allocator> sparseMemoryRequirements;
-    uint32_t                                               sparseMemoryRequirementCount;
+    std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> sparseMemoryRequirements;
+    uint32_t                                                                             sparseMemoryRequirementCount;
     d.vkGetImageSparseMemoryRequirements2( m_device,
                                            reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ),
                                            &sparseMemoryRequirementCount,
@@ -97682,18 +97698,25 @@ namespace VULKAN_HPP_NAMESPACE
       reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ),
       &sparseMemoryRequirementCount,
       reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) );
+    VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() );
     return sparseMemoryRequirements;
   }
+
   template <
-    typename Allocator,
+    typename SparseImageMemoryRequirements2Allocator,
     typename Dispatch,
     typename B,
     typename std::enable_if<std::is_same<typename B::value_type, SparseImageMemoryRequirements2>::value, int>::type>
-  VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements2, Allocator> Device::getImageSparseMemoryRequirements2(
-    const ImageSparseMemoryRequirementsInfo2 & info, Allocator const & vectorAllocator, Dispatch const & d ) const
+  VULKAN_HPP_NODISCARD
+    VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
+                      Device::getImageSparseMemoryRequirements2(
+      const ImageSparseMemoryRequirementsInfo2 & info,
+      SparseImageMemoryRequirements2Allocator &  sparseMemoryRequirementsAllocator,
+      Dispatch const &                           d ) const
   {
-    std::vector<SparseImageMemoryRequirements2, Allocator> sparseMemoryRequirements( vectorAllocator );
-    uint32_t                                               sparseMemoryRequirementCount;
+    std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> sparseMemoryRequirements(
+      SparseImageMemoryRequirements2Allocator );
+    uint32_t sparseMemoryRequirementCount;
     d.vkGetImageSparseMemoryRequirements2( m_device,
                                            reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ),
                                            &sparseMemoryRequirementCount,
@@ -97704,6 +97727,7 @@ namespace VULKAN_HPP_NAMESPACE
       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*/
@@ -97721,14 +97745,16 @@ namespace VULKAN_HPP_NAMESPACE
       pSparseMemoryRequirementCount,
       reinterpret_cast<VkSparseImageMemoryRequirements2 *>( pSparseMemoryRequirements ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator, typename Dispatch>
-  VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements2, Allocator>
-                    Device::getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info,
+  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, Allocator> sparseMemoryRequirements;
-    uint32_t                                               sparseMemoryRequirementCount;
+    std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> sparseMemoryRequirements;
+    uint32_t                                                                             sparseMemoryRequirementCount;
     d.vkGetImageSparseMemoryRequirements2KHR( m_device,
                                               reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ),
                                               &sparseMemoryRequirementCount,
@@ -97739,18 +97765,25 @@ namespace VULKAN_HPP_NAMESPACE
       reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ),
       &sparseMemoryRequirementCount,
       reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) );
+    VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() );
     return sparseMemoryRequirements;
   }
+
   template <
-    typename Allocator,
+    typename SparseImageMemoryRequirements2Allocator,
     typename Dispatch,
     typename B,
     typename std::enable_if<std::is_same<typename B::value_type, SparseImageMemoryRequirements2>::value, int>::type>
-  VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements2, Allocator> Device::getImageSparseMemoryRequirements2KHR(
-    const ImageSparseMemoryRequirementsInfo2 & info, Allocator const & vectorAllocator, Dispatch const & d ) const
+  VULKAN_HPP_NODISCARD
+    VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
+                      Device::getImageSparseMemoryRequirements2KHR(
+      const ImageSparseMemoryRequirementsInfo2 & info,
+      SparseImageMemoryRequirements2Allocator &  sparseMemoryRequirementsAllocator,
+      Dispatch const &                           d ) const
   {
-    std::vector<SparseImageMemoryRequirements2, Allocator> sparseMemoryRequirements( vectorAllocator );
-    uint32_t                                               sparseMemoryRequirementCount;
+    std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> sparseMemoryRequirements(
+      SparseImageMemoryRequirements2Allocator );
+    uint32_t sparseMemoryRequirementCount;
     d.vkGetImageSparseMemoryRequirements2KHR( m_device,
                                               reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ),
                                               &sparseMemoryRequirementCount,
@@ -97761,6 +97794,7 @@ namespace VULKAN_HPP_NAMESPACE
       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*/
@@ -103362,36 +103396,42 @@ namespace VULKAN_HPP_NAMESPACE
                                                 pQueueFamilyPropertyCount,
                                                 reinterpret_cast<VkQueueFamilyProperties *>( pQueueFamilyProperties ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator, typename Dispatch>
-  VULKAN_HPP_INLINE std::vector<QueueFamilyProperties, Allocator>
-                    PhysicalDevice::getQueueFamilyProperties( Dispatch const & d ) const
+  template <typename QueueFamilyPropertiesAllocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<QueueFamilyProperties, QueueFamilyPropertiesAllocator>
+                                         PhysicalDevice::getQueueFamilyProperties( Dispatch const & d ) const
   {
-    std::vector<QueueFamilyProperties, Allocator> queueFamilyProperties;
-    uint32_t                                      queueFamilyPropertyCount;
+    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 Allocator,
+
+  template <typename QueueFamilyPropertiesAllocator,
             typename Dispatch,
             typename B,
             typename std::enable_if<std::is_same<typename B::value_type, QueueFamilyProperties>::value, int>::type>
-  VULKAN_HPP_INLINE std::vector<QueueFamilyProperties, Allocator>
-                    PhysicalDevice::getQueueFamilyProperties( Allocator const & vectorAllocator, Dispatch const & d ) const
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<QueueFamilyProperties, QueueFamilyPropertiesAllocator>
+                                         PhysicalDevice::getQueueFamilyProperties( QueueFamilyPropertiesAllocator & queueFamilyPropertiesAllocator,
+                                              Dispatch const &                 d ) const
   {
-    std::vector<QueueFamilyProperties, Allocator> queueFamilyProperties( vectorAllocator );
-    uint32_t                                      queueFamilyPropertyCount;
+    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*/
@@ -103603,18 +103643,19 @@ namespace VULKAN_HPP_NAMESPACE
       pPropertyCount,
       reinterpret_cast<VkSparseImageFormatProperties *>( pProperties ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator, typename Dispatch>
-  VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties, Allocator>
-                    PhysicalDevice::getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format              format,
+  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, Allocator> properties;
-    uint32_t                                            propertyCount;
+    std::vector<SparseImageFormatProperties, SparseImageFormatPropertiesAllocator> properties;
+    uint32_t                                                                       propertyCount;
     d.vkGetPhysicalDeviceSparseImageFormatProperties( m_physicalDevice,
                                                       static_cast<VkFormat>( format ),
                                                       static_cast<VkImageType>( type ),
@@ -103633,24 +103674,27 @@ namespace VULKAN_HPP_NAMESPACE
       static_cast<VkImageTiling>( tiling ),
       &propertyCount,
       reinterpret_cast<VkSparseImageFormatProperties *>( properties.data() ) );
+    VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
     return properties;
   }
+
   template <
-    typename Allocator,
+    typename SparseImageFormatPropertiesAllocator,
     typename Dispatch,
     typename B,
     typename std::enable_if<std::is_same<typename B::value_type, SparseImageFormatProperties>::value, int>::type>
-  VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties, Allocator>
-                    PhysicalDevice::getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format              format,
+  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,
-                                                    Allocator const &                         vectorAllocator,
+                                                    SparseImageFormatPropertiesAllocator &    propertiesAllocator,
                                                     Dispatch const &                          d ) const
   {
-    std::vector<SparseImageFormatProperties, Allocator> properties( vectorAllocator );
-    uint32_t                                            propertyCount;
+    std::vector<SparseImageFormatProperties, SparseImageFormatPropertiesAllocator> properties(
+      SparseImageFormatPropertiesAllocator );
+    uint32_t propertyCount;
     d.vkGetPhysicalDeviceSparseImageFormatProperties( m_physicalDevice,
                                                       static_cast<VkFormat>( format ),
                                                       static_cast<VkImageType>( type ),
@@ -103669,6 +103713,7 @@ namespace VULKAN_HPP_NAMESPACE
       static_cast<VkImageTiling>( tiling ),
       &propertyCount,
       reinterpret_cast<VkSparseImageFormatProperties *>( properties.data() ) );
+    VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
     return properties;
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@@ -103686,14 +103731,16 @@ namespace VULKAN_HPP_NAMESPACE
       pPropertyCount,
       reinterpret_cast<VkSparseImageFormatProperties2 *>( pProperties ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator, typename Dispatch>
-  VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties2, Allocator>
-                    PhysicalDevice::getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
+  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, Allocator> properties;
-    uint32_t                                             propertyCount;
+    std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> properties;
+    uint32_t                                                                         propertyCount;
     d.vkGetPhysicalDeviceSparseImageFormatProperties2(
       m_physicalDevice,
       reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ),
@@ -103705,20 +103752,24 @@ namespace VULKAN_HPP_NAMESPACE
       reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ),
       &propertyCount,
       reinterpret_cast<VkSparseImageFormatProperties2 *>( properties.data() ) );
+    VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
     return properties;
   }
+
   template <
-    typename Allocator,
+    typename SparseImageFormatProperties2Allocator,
     typename Dispatch,
     typename B,
     typename std::enable_if<std::is_same<typename B::value_type, SparseImageFormatProperties2>::value, int>::type>
-  VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties2, Allocator>
-                    PhysicalDevice::getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
-                                                     Allocator const &                            vectorAllocator,
+  VULKAN_HPP_NODISCARD
+    VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
+                      PhysicalDevice::getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
+                                                     SparseImageFormatProperties2Allocator &      propertiesAllocator,
                                                      Dispatch const &                             d ) const
   {
-    std::vector<SparseImageFormatProperties2, Allocator> properties( vectorAllocator );
-    uint32_t                                             propertyCount;
+    std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> properties(
+      SparseImageFormatProperties2Allocator );
+    uint32_t propertyCount;
     d.vkGetPhysicalDeviceSparseImageFormatProperties2(
       m_physicalDevice,
       reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ),
@@ -103730,6 +103781,7 @@ namespace VULKAN_HPP_NAMESPACE
       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*/
@@ -103747,14 +103799,16 @@ namespace VULKAN_HPP_NAMESPACE
       pPropertyCount,
       reinterpret_cast<VkSparseImageFormatProperties2 *>( pProperties ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator, typename Dispatch>
-  VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties2, Allocator>
-                    PhysicalDevice::getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
+  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, Allocator> properties;
-    uint32_t                                             propertyCount;
+    std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> properties;
+    uint32_t                                                                         propertyCount;
     d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
       m_physicalDevice,
       reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ),
@@ -103766,20 +103820,24 @@ namespace VULKAN_HPP_NAMESPACE
       reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ),
       &propertyCount,
       reinterpret_cast<VkSparseImageFormatProperties2 *>( properties.data() ) );
+    VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
     return properties;
   }
+
   template <
-    typename Allocator,
+    typename SparseImageFormatProperties2Allocator,
     typename Dispatch,
     typename B,
     typename std::enable_if<std::is_same<typename B::value_type, SparseImageFormatProperties2>::value, int>::type>
-  VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties2, Allocator>
-                    PhysicalDevice::getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
-                                                        Allocator const &                            vectorAllocator,
-                                                        Dispatch const &                             d ) const
+  VULKAN_HPP_NODISCARD
+    VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
+                      PhysicalDevice::getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
+                                                        SparseImageFormatProperties2Allocator & propertiesAllocator,
+                                                        Dispatch const &                        d ) const
   {
-    std::vector<SparseImageFormatProperties2, Allocator> properties( vectorAllocator );
-    uint32_t                                             propertyCount;
+    std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> properties(
+      SparseImageFormatProperties2Allocator );
+    uint32_t propertyCount;
     d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
       m_physicalDevice,
       reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ),
@@ -103791,6 +103849,7 @@ namespace VULKAN_HPP_NAMESPACE
       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*/
@@ -104536,31 +104595,36 @@ namespace VULKAN_HPP_NAMESPACE
     d.vkGetQueueCheckpointDataNV(
       m_queue, pCheckpointDataCount, reinterpret_cast<VkCheckpointDataNV *>( pCheckpointData ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator, typename Dispatch>
-  VULKAN_HPP_INLINE std::vector<CheckpointDataNV, Allocator> Queue::getCheckpointDataNV( Dispatch const & d ) const
+  template <typename CheckpointDataNVAllocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<CheckpointDataNV, CheckpointDataNVAllocator>
+                                         Queue::getCheckpointDataNV( Dispatch const & d ) const
   {
-    std::vector<CheckpointDataNV, Allocator> checkpointData;
-    uint32_t                                 checkpointDataCount;
+    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 Allocator,
+
+  template <typename CheckpointDataNVAllocator,
             typename Dispatch,
             typename B,
             typename std::enable_if<std::is_same<typename B::value_type, CheckpointDataNV>::value, int>::type>
-  VULKAN_HPP_INLINE std::vector<CheckpointDataNV, Allocator>
-                    Queue::getCheckpointDataNV( Allocator const & vectorAllocator, Dispatch const & d ) const
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<CheckpointDataNV, CheckpointDataNVAllocator>
+                                         Queue::getCheckpointDataNV( CheckpointDataNVAllocator & checkpointDataAllocator, Dispatch const & d ) const
   {
-    std::vector<CheckpointDataNV, Allocator> checkpointData( vectorAllocator );
-    uint32_t                                 checkpointDataCount;
+    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*/