diff --git a/VulkanHppGenerator.cpp b/VulkanHppGenerator.cpp
index ec70e54..a42ab77 100644
--- a/VulkanHppGenerator.cpp
+++ b/VulkanHppGenerator.cpp
@@ -1952,7 +1952,7 @@ void VulkanHppGenerator::appendFunction( std::string &                    str,
                                          bool                             singular,
                                          bool                             unique,
                                          bool                             isStructureChain,
-                                         bool                             withAllocator ) const
+                                         bool                             withAllocatorArgument ) const
 {
   appendFunctionHeaderTemplate( str,
                                 indentation,
@@ -1963,7 +1963,8 @@ void VulkanHppGenerator::appendFunction( std::string &                    str,
                                 singular,
                                 unique,
                                 !definition,
-                                isStructureChain );
+                                isStructureChain,
+                                withAllocatorArgument );
 
   str += indentation;
 
@@ -2013,7 +2014,7 @@ void VulkanHppGenerator::appendFunction( std::string &                    str,
                                  enhanced,
                                  singular,
                                  !definition,
-                                 withAllocator );
+                                 withAllocatorArgument );
 
   // Any function that originally does not return VkResult can be marked noexcept,
   // if it is enhanced it must not include anything with an Allocator or needs size checks on multiple vectors
@@ -2045,7 +2046,7 @@ void VulkanHppGenerator::appendFunction( std::string &                    str,
                                   singular,
                                   unique,
                                   isStructureChain,
-                                  withAllocator );
+                                  withAllocatorArgument );
     }
     else
     {
@@ -3044,9 +3045,11 @@ void VulkanHppGenerator::appendFunctionHeaderTemplate( std::string &       str,
                                                        bool                singular,
                                                        bool                unique,
                                                        bool                withDefault,
-                                                       bool                isStructureChain ) const
+                                                       bool                isStructureChain,
+                                                       bool                withAllocatorArgument ) const
 {
-  bool withAllocator = ( enhancedReturnType.find( "Allocator" ) != std::string::npos );
+  bool        withAllocator = ( enhancedReturnType.find( "Allocator" ) != std::string::npos );
+  std::string enhancedReturnTypeBase;
   str += indentation + "template<";
   if ( enhanced )
   {
@@ -3060,27 +3063,43 @@ void VulkanHppGenerator::appendFunctionHeaderTemplate( std::string &       str,
       assert( !withAllocator );
       str += "typename T, ";
     }
-    if ( !singular && withAllocator )
-    {
-      // otherwise, if there's an Allocator used in the enhanced return type, we templatize on that Allocator
-      assert( ( enhancedReturnType.substr( 0, 12 ) == "std::vector<" ) &&
-              ( enhancedReturnType.find( ',' ) != std::string::npos ) && ( 12 < enhancedReturnType.find( ',' ) ) );
-      str += "typename Allocator";
-      if ( withDefault )
-      {
-        // for the default type get the type from the enhancedReturnType, which is of the form
-        // 'std::vector<Type,Allocator>'
-        assert( !isStructureChain || !unique );
-        str += " = std::allocator<" +
-               ( isStructureChain ? "StructureChain"
-                                  : ( unique ? "Unique" : "" ) +
-                                      enhancedReturnType.substr( 12, enhancedReturnType.find( ',' ) - 12 ) ) +
-               ">";
-      }
-      str += ", ";
-    }
   }
-  str += std::string( "typename Dispatch" ) + ( withDefault ? " = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE" : "" ) + ">\n";
+  std::string dispatch =
+    std::string( "typename Dispatch" ) + ( withDefault ? " = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE" : "" );
+  if ( enhanced && !singular && withAllocator )
+  {
+    // otherwise, if there's an Allocator used in the enhanced return type, we templatize on that Allocator
+    assert( ( enhancedReturnType.substr( 0, 12 ) == "std::vector<" ) &&
+            ( enhancedReturnType.find( ',' ) != std::string::npos ) && ( 12 < enhancedReturnType.find( ',' ) ) );
+    std::string allocator  = "typename Allocator ";
+    enhancedReturnTypeBase = enhancedReturnType.substr( 12, enhancedReturnType.find( ',' ) - 12 );
+    if ( unique )
+    {
+      enhancedReturnTypeBase = "UniqueHandle<" + enhancedReturnTypeBase + ", Dispatch>";
+    }
+    if ( withDefault )
+    {
+      // for the default type get the type from the enhancedReturnType, which is of the form
+      // 'std::vector<Type,Allocator>'
+      assert( !isStructureChain || !unique );
+      allocator += " = std::allocator<" + ( isStructureChain ? "StructureChain" : enhancedReturnTypeBase ) + ">";
+    }
+    // Use first Dispatch, then Allocator template argument for functions returning a std::vector<UniqueHandle>, as they
+    // need the Dispatch in the Allocator. For all other functions keep the previous order: first Allocator, then
+    // Dispatch
+    str += unique ? ( dispatch + ", " + allocator ) : ( allocator + ", " + dispatch );
+  }
+  else
+  {
+    str += dispatch;
+  }
+  if ( enhanced && !singular && withAllocatorArgument )
+  {
+    str += std::string( ", typename B" ) + ( withDefault ? " = Allocator" : "" );
+    str += ", typename std::enable_if<std::is_same<typename B::value_type, " + enhancedReturnTypeBase +
+           ">::value, int>::type" + ( withDefault ? " = 0" : "" );
+  }
+  str += ">\n";
 }
 
 void VulkanHppGenerator::appendHandle( std::string & str, std::pair<std::string, HandleData> const & handleData )
diff --git a/VulkanHppGenerator.hpp b/VulkanHppGenerator.hpp
index b4748ed..e7a7c4b 100644
--- a/VulkanHppGenerator.hpp
+++ b/VulkanHppGenerator.hpp
@@ -116,7 +116,7 @@ private:
   struct EnumValueData
   {
     EnumValueData( int line, std::string const & vulkan, std::string const & vk, bool singleBit_ )
-      : vulkanValue( vulkan ), vkValue( vk ), singleBit( singleBit_ ), xmlLine(line)
+      : vulkanValue( vulkan ), vkValue( vk ), singleBit( singleBit_ ), xmlLine( line )
     {}
 
     std::string vulkanValue;
@@ -312,7 +312,7 @@ private:
                               bool                             singular,
                               bool                             unique,
                               bool                             isStructureChain,
-                              bool                             withAllocator ) const;
+                              bool                             withAllocatorArgument ) const;
   void        appendFunctionBodyEnhanced( std::string &                    str,
                                           std::string const &              indentation,
                                           std::string const &              name,
@@ -466,11 +466,10 @@ private:
                                      bool                singular,
                                      bool                unique,
                                      bool                withDefault,
-                                     bool                isStructureChain ) const;
-  void appendHandle( std::string &                              str,
-                     std::pair<std::string, HandleData> const & handle );
-  void appendStruct( std::string &                                 str,
-                     std::pair<std::string, StructureData> const & structure );
+                                     bool                isStructureChain,
+                                     bool                withAllocatorArgument ) const;
+  void appendHandle( std::string & str, std::pair<std::string, HandleData> const & handle );
+  void appendStruct( std::string & str, std::pair<std::string, StructureData> const & structure );
   void appendStructAssignmentOperators( std::string &                                 str,
                                         std::pair<std::string, StructureData> const & structure,
                                         std::string const &                           prefix ) const;
diff --git a/tests/DeviceFunctions/DeviceFunctions.cpp b/tests/DeviceFunctions/DeviceFunctions.cpp
index 6ed9f66..b400588 100644
--- a/tests/DeviceFunctions/DeviceFunctions.cpp
+++ b/tests/DeviceFunctions/DeviceFunctions.cpp
@@ -30,6 +30,9 @@ int main( int /*argc*/, char ** /*argv*/ )
     vk::UniqueInstance  instance       = vk::createInstanceUnique( vk::InstanceCreateInfo( {}, &appInfo ) );
     vk::PhysicalDevice  physicalDevice = instance->enumeratePhysicalDevices().front();
 
+    uint32_t propertyCount;
+    physicalDevice.getQueueFamilyProperties( &propertyCount, nullptr );
+
     // get the QueueFamilyProperties of the first PhysicalDevice
     std::vector<vk::QueueFamilyProperties> queueFamilyProperties = physicalDevice.getQueueFamilyProperties();
 
diff --git a/vulkan/vulkan.hpp b/vulkan/vulkan.hpp
index f1b83d8..8be6c57 100644
--- a/vulkan/vulkan.hpp
+++ b/vulkan/vulkan.hpp
@@ -45406,7 +45406,9 @@ namespace VULKAN_HPP_NAMESPACE
     std::vector<CheckpointDataNV, Allocator>
       getCheckpointDataNV( Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
     template <typename Allocator = std::allocator<CheckpointDataNV>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B         = Allocator,
+              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 ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@@ -49533,20 +49535,26 @@ namespace VULKAN_HPP_NAMESPACE
       allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo,
                               Dispatch const &                  d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
     template <typename Allocator = std::allocator<CommandBuffer>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B         = Allocator,
+              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, Allocator>>::type
       allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo,
                               Allocator const &                 vectorAllocator,
                               Dispatch const &                  d ) const;
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Allocator = std::allocator<UniqueCommandBuffer>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    template <typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename Allocator = std::allocator<UniqueHandle<CommandBuffer, Dispatch>>>
     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
       typename ResultValueType<std::vector<UniqueHandle<CommandBuffer, Dispatch>, Allocator>>::type
       allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo,
                                     Dispatch const &                  d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
-    template <typename Allocator = std::allocator<UniqueCommandBuffer>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    template <
+      typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+      typename Allocator                 = std::allocator<UniqueHandle<CommandBuffer, Dispatch>>,
+      typename B                         = Allocator,
+      typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<CommandBuffer, Dispatch>>::value,
+                              int>::type = 0>
     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
       typename ResultValueType<std::vector<UniqueHandle<CommandBuffer, Dispatch>, Allocator>>::type
       allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo,
@@ -49567,20 +49575,26 @@ namespace VULKAN_HPP_NAMESPACE
       allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo,
                               Dispatch const &                  d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
     template <typename Allocator = std::allocator<DescriptorSet>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B         = Allocator,
+              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, Allocator>>::type
       allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo,
                               Allocator const &                 vectorAllocator,
                               Dispatch const &                  d ) const;
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Allocator = std::allocator<UniqueDescriptorSet>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    template <typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename Allocator = std::allocator<UniqueHandle<DescriptorSet, Dispatch>>>
     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
       typename ResultValueType<std::vector<UniqueHandle<DescriptorSet, Dispatch>, Allocator>>::type
       allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo,
                                     Dispatch const &                  d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
-    template <typename Allocator = std::allocator<UniqueDescriptorSet>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    template <
+      typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+      typename Allocator                 = std::allocator<UniqueHandle<DescriptorSet, Dispatch>>,
+      typename B                         = Allocator,
+      typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<DescriptorSet, Dispatch>>::value,
+                              int>::type = 0>
     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
       typename ResultValueType<std::vector<UniqueHandle<DescriptorSet, Dispatch>, Allocator>>::type
       allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo,
@@ -49906,7 +49920,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                  ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos,
                                                  Optional<const AllocationCallbacks> allocator = nullptr,
                                                  Dispatch const &                    d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
-    template <typename Allocator = std::allocator<Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    template <typename Allocator = std::allocator<Pipeline>,
+              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B         = Allocator,
+              typename std::enable_if<std::is_same<typename B::value_type, Pipeline>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, Allocator>>
                          createComputePipelines( VULKAN_HPP_NAMESPACE::PipelineCache                                       pipelineCache,
                                                  ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos,
@@ -49920,16 +49937,19 @@ namespace VULKAN_HPP_NAMESPACE
                                                 Optional<const AllocationCallbacks> allocator = nullptr,
                                                 Dispatch const &                    d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Allocator = std::allocator<UniquePipeline>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    template <typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename Allocator = std::allocator<UniqueHandle<Pipeline, Dispatch>>>
     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator>>
                          createComputePipelinesUnique(
                            VULKAN_HPP_NAMESPACE::PipelineCache                                       pipelineCache,
                            ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos,
                            Optional<const AllocationCallbacks>                                       allocator = nullptr,
                            Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
-    template <typename Allocator = std::allocator<UniquePipeline>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    template <typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename Allocator                 = std::allocator<UniqueHandle<Pipeline, Dispatch>>,
+              typename B                         = Allocator,
+              typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<Pipeline, Dispatch>>::value,
+                                      int>::type = 0>
     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator>>
                          createComputePipelinesUnique(
                            VULKAN_HPP_NAMESPACE::PipelineCache                                       pipelineCache,
@@ -50131,7 +50151,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                   ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
                                                   Optional<const AllocationCallbacks> allocator = nullptr,
                                                   Dispatch const &                    d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
-    template <typename Allocator = std::allocator<Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    template <typename Allocator = std::allocator<Pipeline>,
+              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B         = Allocator,
+              typename std::enable_if<std::is_same<typename B::value_type, Pipeline>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, Allocator>>
                          createGraphicsPipelines( VULKAN_HPP_NAMESPACE::PipelineCache                                        pipelineCache,
                                                   ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
@@ -50145,16 +50168,19 @@ namespace VULKAN_HPP_NAMESPACE
                                                  Optional<const AllocationCallbacks> allocator = nullptr,
                                                  Dispatch const &                    d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Allocator = std::allocator<UniquePipeline>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    template <typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename Allocator = std::allocator<UniqueHandle<Pipeline, Dispatch>>>
     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator>>
                          createGraphicsPipelinesUnique(
                            VULKAN_HPP_NAMESPACE::PipelineCache                                        pipelineCache,
                            ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
                            Optional<const AllocationCallbacks>                                        allocator = nullptr,
                            Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
-    template <typename Allocator = std::allocator<UniquePipeline>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    template <typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename Allocator                 = std::allocator<UniqueHandle<Pipeline, Dispatch>>,
+              typename B                         = Allocator,
+              typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<Pipeline, Dispatch>>::value,
+                                      int>::type = 0>
     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator>>
                          createGraphicsPipelinesUnique(
                            VULKAN_HPP_NAMESPACE::PipelineCache                                        pipelineCache,
@@ -50335,7 +50361,10 @@ namespace VULKAN_HPP_NAMESPACE
       ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos,
       Optional<const AllocationCallbacks>                                             allocator = nullptr,
       Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
-    template <typename Allocator = std::allocator<Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    template <typename Allocator = std::allocator<Pipeline>,
+              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B         = Allocator,
+              typename std::enable_if<std::is_same<typename B::value_type, Pipeline>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, Allocator>> createRayTracingPipelinesKHR(
       VULKAN_HPP_NAMESPACE::PipelineCache                                             pipelineCache,
       ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos,
@@ -50349,16 +50378,19 @@ namespace VULKAN_HPP_NAMESPACE
                                                       Optional<const AllocationCallbacks>     allocator = nullptr,
                                                       Dispatch const &                        d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Allocator = std::allocator<UniquePipeline>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    template <typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename Allocator = std::allocator<UniqueHandle<Pipeline, Dispatch>>>
     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator>>
                          createRayTracingPipelinesKHRUnique(
                            VULKAN_HPP_NAMESPACE::PipelineCache                                             pipelineCache,
                            ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos,
                            Optional<const AllocationCallbacks>                                             allocator = nullptr,
                            Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
-    template <typename Allocator = std::allocator<UniquePipeline>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    template <typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename Allocator                 = std::allocator<UniqueHandle<Pipeline, Dispatch>>,
+              typename B                         = Allocator,
+              typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<Pipeline, Dispatch>>::value,
+                                      int>::type = 0>
     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator>>
                          createRayTracingPipelinesKHRUnique(
                            VULKAN_HPP_NAMESPACE::PipelineCache                                             pipelineCache,
@@ -50391,7 +50423,10 @@ namespace VULKAN_HPP_NAMESPACE
       ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
       Optional<const AllocationCallbacks>                                            allocator = nullptr,
       Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
-    template <typename Allocator = std::allocator<Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    template <typename Allocator = std::allocator<Pipeline>,
+              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B         = Allocator,
+              typename std::enable_if<std::is_same<typename B::value_type, Pipeline>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, Allocator>> createRayTracingPipelinesNV(
       VULKAN_HPP_NAMESPACE::PipelineCache                                            pipelineCache,
       ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
@@ -50405,16 +50440,19 @@ namespace VULKAN_HPP_NAMESPACE
                                                      Optional<const AllocationCallbacks>    allocator = nullptr,
                                                      Dispatch const &                       d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Allocator = std::allocator<UniquePipeline>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    template <typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename Allocator = std::allocator<UniqueHandle<Pipeline, Dispatch>>>
     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator>>
                          createRayTracingPipelinesNVUnique(
                            VULKAN_HPP_NAMESPACE::PipelineCache                                            pipelineCache,
                            ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
                            Optional<const AllocationCallbacks>                                            allocator = nullptr,
                            Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
-    template <typename Allocator = std::allocator<UniquePipeline>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    template <typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename Allocator                 = std::allocator<UniqueHandle<Pipeline, Dispatch>>,
+              typename B                         = Allocator,
+              typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<Pipeline, Dispatch>>::value,
+                                      int>::type = 0>
     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator>>
                          createRayTracingPipelinesNVUnique(
                            VULKAN_HPP_NAMESPACE::PipelineCache                                            pipelineCache,
@@ -50614,7 +50652,10 @@ namespace VULKAN_HPP_NAMESPACE
       createSharedSwapchainsKHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
                                  Optional<const AllocationCallbacks> allocator = nullptr,
                                  Dispatch const &                    d         = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
-    template <typename Allocator = std::allocator<SwapchainKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    template <typename Allocator = std::allocator<SwapchainKHR>,
+              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B         = Allocator,
+              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, Allocator>>::type
       createSharedSwapchainsKHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
                                  Optional<const AllocationCallbacks>                                    allocator,
@@ -50626,16 +50667,19 @@ namespace VULKAN_HPP_NAMESPACE
                                 Optional<const AllocationCallbacks> allocator = nullptr,
                                 Dispatch const &                    d         = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Allocator = std::allocator<UniqueSwapchainKHR>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    template <typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename Allocator = std::allocator<UniqueHandle<SwapchainKHR, Dispatch>>>
     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
       typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR, Dispatch>, Allocator>>::type
       createSharedSwapchainsKHRUnique(
         ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
         Optional<const AllocationCallbacks>                                    allocator = nullptr,
         Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
-    template <typename Allocator = std::allocator<UniqueSwapchainKHR>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    template <typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename Allocator                 = std::allocator<UniqueHandle<SwapchainKHR, Dispatch>>,
+              typename B                         = Allocator,
+              typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<SwapchainKHR, Dispatch>>::value,
+                                      int>::type = 0>
     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
       typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR, Dispatch>, Allocator>>::type
       createSharedSwapchainsKHRUnique(
@@ -51971,8 +52015,11 @@ namespace VULKAN_HPP_NAMESPACE
     std::vector<SparseImageMemoryRequirements, Allocator>
       getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image,
                                         Dispatch const &            d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
-    template <typename Allocator = std::allocator<SparseImageMemoryRequirements>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    template <typename Allocator                 = std::allocator<SparseImageMemoryRequirements>,
+              typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B                         = Allocator,
+              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 ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@@ -51989,8 +52036,11 @@ namespace VULKAN_HPP_NAMESPACE
     std::vector<SparseImageMemoryRequirements2, Allocator>
       getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info,
                                          Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
-    template <typename Allocator = std::allocator<SparseImageMemoryRequirements2>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    template <typename Allocator                 = std::allocator<SparseImageMemoryRequirements2>,
+              typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B                         = Allocator,
+              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 ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@@ -52007,8 +52057,11 @@ namespace VULKAN_HPP_NAMESPACE
     std::vector<SparseImageMemoryRequirements2, Allocator>
       getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info,
                                             Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
-    template <typename Allocator = std::allocator<SparseImageMemoryRequirements2>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    template <typename Allocator                 = std::allocator<SparseImageMemoryRequirements2>,
+              typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B                         = Allocator,
+              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 ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@@ -52156,8 +52209,11 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PastPresentationTimingGOOGLE, Allocator>>::type
       getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
                                        Dispatch const &                   d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
-    template <typename Allocator = std::allocator<PastPresentationTimingGOOGLE>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    template <
+      typename Allocator = std::allocator<PastPresentationTimingGOOGLE>,
+      typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+      typename B         = Allocator,
+      typename std::enable_if<std::is_same<typename B::value_type, PastPresentationTimingGOOGLE>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PastPresentationTimingGOOGLE, Allocator>>::type
       getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
                                        Allocator const &                  vectorAllocator,
@@ -52187,7 +52243,10 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Allocator>>::type
       getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
                             Dispatch const &                    d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
-    template <typename Allocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    template <typename Allocator = std::allocator<uint8_t>,
+              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B         = Allocator,
+              typename std::enable_if<std::is_same<typename B::value_type, uint8_t>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Allocator>>::type getPipelineCacheData(
       VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, Allocator const & vectorAllocator, Dispatch const & d ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@@ -52205,8 +52264,12 @@ namespace VULKAN_HPP_NAMESPACE
       typename ResultValueType<std::vector<PipelineExecutableInternalRepresentationKHR, Allocator>>::type
       getPipelineExecutableInternalRepresentationsKHR( const PipelineExecutableInfoKHR & executableInfo,
                                                        Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
-    template <typename Allocator = std::allocator<PipelineExecutableInternalRepresentationKHR>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    template <
+      typename Allocator                 = std::allocator<PipelineExecutableInternalRepresentationKHR>,
+      typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+      typename B                         = Allocator,
+      typename std::enable_if<std::is_same<typename B::value_type, PipelineExecutableInternalRepresentationKHR>::value,
+                              int>::type = 0>
     VULKAN_HPP_NODISCARD
       typename ResultValueType<std::vector<PipelineExecutableInternalRepresentationKHR, Allocator>>::type
       getPipelineExecutableInternalRepresentationsKHR( const PipelineExecutableInfoKHR & executableInfo,
@@ -52226,8 +52289,11 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PipelineExecutablePropertiesKHR, Allocator>>::type
       getPipelineExecutablePropertiesKHR( const PipelineInfoKHR & pipelineInfo,
                                           Dispatch const &        d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
-    template <typename Allocator = std::allocator<PipelineExecutablePropertiesKHR>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    template <typename Allocator                 = std::allocator<PipelineExecutablePropertiesKHR>,
+              typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B                         = Allocator,
+              typename std::enable_if<std::is_same<typename B::value_type, PipelineExecutablePropertiesKHR>::value,
+                                      int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PipelineExecutablePropertiesKHR, Allocator>>::type
       getPipelineExecutablePropertiesKHR( const PipelineInfoKHR & pipelineInfo,
                                           Allocator const &       vectorAllocator,
@@ -52246,8 +52312,11 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PipelineExecutableStatisticKHR, Allocator>>::type
       getPipelineExecutableStatisticsKHR( const PipelineExecutableInfoKHR & executableInfo,
                                           Dispatch const &                  d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
-    template <typename Allocator = std::allocator<PipelineExecutableStatisticKHR>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    template <typename Allocator                 = std::allocator<PipelineExecutableStatisticKHR>,
+              typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B                         = Allocator,
+              typename std::enable_if<std::is_same<typename B::value_type, PipelineExecutableStatisticKHR>::value,
+                                      int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PipelineExecutableStatisticKHR, Allocator>>::type
       getPipelineExecutableStatisticsKHR( const PipelineExecutableInfoKHR & executableInfo,
                                           Allocator const &                 vectorAllocator,
@@ -52436,7 +52505,10 @@ namespace VULKAN_HPP_NAMESPACE
                         VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage,
                         VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD   infoType,
                         Dispatch const &                          d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
-    template <typename Allocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    template <typename Allocator = std::allocator<uint8_t>,
+              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B         = Allocator,
+              typename std::enable_if<std::is_same<typename B::value_type, uint8_t>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Allocator>>::type
       getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline            pipeline,
                         VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage,
@@ -52470,7 +52542,10 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<Image, Allocator>>::type
       getSwapchainImagesKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
                              Dispatch const &                   d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
-    template <typename Allocator = std::allocator<Image>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    template <typename Allocator = std::allocator<Image>,
+              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B         = Allocator,
+              typename std::enable_if<std::is_same<typename B::value_type, Image>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<Image, Allocator>>::type getSwapchainImagesKHR(
       VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Allocator const & vectorAllocator, Dispatch const & d ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@@ -52497,7 +52572,10 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Allocator>>::type
       getValidationCacheDataEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache,
                                  Dispatch const &                         d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
-    template <typename Allocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    template <typename Allocator = std::allocator<uint8_t>,
+              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B         = Allocator,
+              typename std::enable_if<std::is_same<typename B::value_type, uint8_t>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Allocator>>::type
       getValidationCacheDataEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache,
                                  Allocator const &                        vectorAllocator,
@@ -57412,7 +57490,9 @@ namespace VULKAN_HPP_NAMESPACE
       enumerateDeviceExtensionProperties( Optional<const std::string> layerName = nullptr,
                                           Dispatch const &            d         = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
     template <typename Allocator = std::allocator<ExtensionProperties>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B         = Allocator,
+              typename std::enable_if<std::is_same<typename B::value_type, ExtensionProperties>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<ExtensionProperties, Allocator>>::type
       enumerateDeviceExtensionProperties( Optional<const std::string> layerName,
                                           Allocator const &           vectorAllocator,
@@ -57430,7 +57510,9 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<LayerProperties, Allocator>>::type
       enumerateDeviceLayerProperties( Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
     template <typename Allocator = std::allocator<LayerProperties>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B         = Allocator,
+              typename std::enable_if<std::is_same<typename B::value_type, LayerProperties>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<LayerProperties, Allocator>>::type
       enumerateDeviceLayerProperties( Allocator const & vectorAllocator, Dispatch const & d ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@@ -57450,8 +57532,11 @@ namespace VULKAN_HPP_NAMESPACE
         uint32_t                                                        queueFamilyIndex,
         ArrayProxy<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR> const & counters,
         Dispatch const &                                                d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
-    template <typename Allocator = std::allocator<PerformanceCounterDescriptionKHR>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    template <typename Allocator                 = std::allocator<PerformanceCounterDescriptionKHR>,
+              typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B                         = Allocator,
+              typename std::enable_if<std::is_same<typename B::value_type, PerformanceCounterDescriptionKHR>::value,
+                                      int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PerformanceCounterDescriptionKHR, Allocator>>::type
       enumerateQueueFamilyPerformanceQueryCountersKHR(
         uint32_t                                                        queueFamilyIndex,
@@ -57472,8 +57557,11 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayModeProperties2KHR, Allocator>>::type
       getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR display,
                                     Dispatch const &                 d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
-    template <typename Allocator = std::allocator<DisplayModeProperties2KHR>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    template <
+      typename Allocator = std::allocator<DisplayModeProperties2KHR>,
+      typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+      typename B         = Allocator,
+      typename std::enable_if<std::is_same<typename B::value_type, DisplayModeProperties2KHR>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayModeProperties2KHR, Allocator>>::type
       getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR display,
                                     Allocator const &                vectorAllocator,
@@ -57492,8 +57580,11 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayModePropertiesKHR, Allocator>>::type
       getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display,
                                    Dispatch const &                 d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
-    template <typename Allocator = std::allocator<DisplayModePropertiesKHR>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    template <
+      typename Allocator = std::allocator<DisplayModePropertiesKHR>,
+      typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+      typename B         = Allocator,
+      typename std::enable_if<std::is_same<typename B::value_type, DisplayModePropertiesKHR>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayModePropertiesKHR, Allocator>>::type
       getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display,
                                    Allocator const &                vectorAllocator,
@@ -57539,7 +57630,10 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayKHR, Allocator>>::type
       getDisplayPlaneSupportedDisplaysKHR( uint32_t         planeIndex,
                                            Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
-    template <typename Allocator = std::allocator<DisplayKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    template <typename Allocator = std::allocator<DisplayKHR>,
+              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B         = Allocator,
+              typename std::enable_if<std::is_same<typename B::value_type, DisplayKHR>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayKHR, Allocator>>::type
       getDisplayPlaneSupportedDisplaysKHR( uint32_t          planeIndex,
                                            Allocator const & vectorAllocator,
@@ -57557,7 +57651,9 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<TimeDomainEXT, Allocator>>::type
       getCalibrateableTimeDomainsEXT( Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
     template <typename Allocator = std::allocator<TimeDomainEXT>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B         = Allocator,
+              typename std::enable_if<std::is_same<typename B::value_type, TimeDomainEXT>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<TimeDomainEXT, Allocator>>::type
       getCalibrateableTimeDomainsEXT( Allocator const & vectorAllocator, Dispatch const & d ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@@ -57572,8 +57668,11 @@ namespace VULKAN_HPP_NAMESPACE
               typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<CooperativeMatrixPropertiesNV, Allocator>>::type
       getCooperativeMatrixPropertiesNV( Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
-    template <typename Allocator = std::allocator<CooperativeMatrixPropertiesNV>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    template <typename Allocator                 = std::allocator<CooperativeMatrixPropertiesNV>,
+              typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B                         = Allocator,
+              typename std::enable_if<std::is_same<typename B::value_type, CooperativeMatrixPropertiesNV>::value,
+                                      int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<CooperativeMatrixPropertiesNV, Allocator>>::type
       getCooperativeMatrixPropertiesNV( Allocator const & vectorAllocator, Dispatch const & d ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@@ -57603,8 +57702,11 @@ namespace VULKAN_HPP_NAMESPACE
               typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayPlaneProperties2KHR, Allocator>>::type
       getDisplayPlaneProperties2KHR( Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
-    template <typename Allocator = std::allocator<DisplayPlaneProperties2KHR>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    template <
+      typename Allocator = std::allocator<DisplayPlaneProperties2KHR>,
+      typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+      typename B         = Allocator,
+      typename std::enable_if<std::is_same<typename B::value_type, DisplayPlaneProperties2KHR>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayPlaneProperties2KHR, Allocator>>::type
       getDisplayPlaneProperties2KHR( Allocator const & vectorAllocator, Dispatch const & d ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@@ -57619,8 +57721,11 @@ namespace VULKAN_HPP_NAMESPACE
               typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayPlanePropertiesKHR, Allocator>>::type
       getDisplayPlanePropertiesKHR( Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
-    template <typename Allocator = std::allocator<DisplayPlanePropertiesKHR>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    template <
+      typename Allocator = std::allocator<DisplayPlanePropertiesKHR>,
+      typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+      typename B         = Allocator,
+      typename std::enable_if<std::is_same<typename B::value_type, DisplayPlanePropertiesKHR>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayPlanePropertiesKHR, Allocator>>::type
       getDisplayPlanePropertiesKHR( Allocator const & vectorAllocator, Dispatch const & d ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@@ -57635,8 +57740,11 @@ namespace VULKAN_HPP_NAMESPACE
               typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayProperties2KHR, Allocator>>::type
       getDisplayProperties2KHR( Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
-    template <typename Allocator = std::allocator<DisplayProperties2KHR>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    template <
+      typename Allocator = std::allocator<DisplayProperties2KHR>,
+      typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+      typename B         = Allocator,
+      typename std::enable_if<std::is_same<typename B::value_type, DisplayProperties2KHR>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayProperties2KHR, Allocator>>::type
       getDisplayProperties2KHR( Allocator const & vectorAllocator, Dispatch const & d ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@@ -57652,7 +57760,9 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayPropertiesKHR, Allocator>>::type
       getDisplayPropertiesKHR( Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
     template <typename Allocator = std::allocator<DisplayPropertiesKHR>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B         = Allocator,
+              typename std::enable_if<std::is_same<typename B::value_type, DisplayPropertiesKHR>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayPropertiesKHR, Allocator>>::type
       getDisplayPropertiesKHR( Allocator const & vectorAllocator, Dispatch const & d ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@@ -57932,7 +58042,10 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<Rect2D, Allocator>>::type
       getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
                                Dispatch const &                 d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
-    template <typename Allocator = std::allocator<Rect2D>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    template <typename Allocator = std::allocator<Rect2D>,
+              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B         = Allocator,
+              typename std::enable_if<std::is_same<typename B::value_type, Rect2D>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<Rect2D, Allocator>>::type getPresentRectanglesKHR(
       VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Allocator const & vectorAllocator, Dispatch const & d ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@@ -57991,8 +58104,11 @@ namespace VULKAN_HPP_NAMESPACE
               typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     std::vector<QueueFamilyProperties, Allocator>
       getQueueFamilyProperties( Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
-    template <typename Allocator = std::allocator<QueueFamilyProperties>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    template <
+      typename Allocator = std::allocator<QueueFamilyProperties>,
+      typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+      typename B         = Allocator,
+      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 ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@@ -58006,8 +58122,11 @@ namespace VULKAN_HPP_NAMESPACE
               typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     std::vector<QueueFamilyProperties2, Allocator>
       getQueueFamilyProperties2( Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
-    template <typename Allocator = std::allocator<QueueFamilyProperties2>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    template <
+      typename Allocator = std::allocator<QueueFamilyProperties2>,
+      typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+      typename B         = Allocator,
+      typename std::enable_if<std::is_same<typename B::value_type, QueueFamilyProperties2>::value, int>::type = 0>
     std::vector<QueueFamilyProperties2, Allocator> getQueueFamilyProperties2( Allocator const & vectorAllocator,
                                                                               Dispatch const &  d ) const;
     template <typename StructureChain,
@@ -58017,7 +58136,9 @@ namespace VULKAN_HPP_NAMESPACE
       getQueueFamilyProperties2( Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
     template <typename StructureChain,
               typename Allocator = std::allocator<StructureChain>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B         = Allocator,
+              typename std::enable_if<std::is_same<typename B::value_type, StructureChain>::value, int>::type = 0>
     std::vector<StructureChain, Allocator> getQueueFamilyProperties2( Allocator const & vectorAllocator,
                                                                       Dispatch const &  d ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@@ -58031,8 +58152,11 @@ namespace VULKAN_HPP_NAMESPACE
               typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     std::vector<QueueFamilyProperties2, Allocator>
       getQueueFamilyProperties2KHR( Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
-    template <typename Allocator = std::allocator<QueueFamilyProperties2>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    template <
+      typename Allocator = std::allocator<QueueFamilyProperties2>,
+      typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+      typename B         = Allocator,
+      typename std::enable_if<std::is_same<typename B::value_type, QueueFamilyProperties2>::value, int>::type = 0>
     std::vector<QueueFamilyProperties2, Allocator> getQueueFamilyProperties2KHR( Allocator const & vectorAllocator,
                                                                                  Dispatch const &  d ) const;
     template <typename StructureChain,
@@ -58042,7 +58166,9 @@ namespace VULKAN_HPP_NAMESPACE
       getQueueFamilyProperties2KHR( Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
     template <typename StructureChain,
               typename Allocator = std::allocator<StructureChain>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B         = Allocator,
+              typename std::enable_if<std::is_same<typename B::value_type, StructureChain>::value, int>::type = 0>
     std::vector<StructureChain, Allocator> getQueueFamilyProperties2KHR( Allocator const & vectorAllocator,
                                                                          Dispatch const &  d ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@@ -58066,8 +58192,11 @@ namespace VULKAN_HPP_NAMESPACE
                                       VULKAN_HPP_NAMESPACE::ImageUsageFlags     usage,
                                       VULKAN_HPP_NAMESPACE::ImageTiling         tiling,
                                       Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
-    template <typename Allocator = std::allocator<SparseImageFormatProperties>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    template <
+      typename Allocator = std::allocator<SparseImageFormatProperties>,
+      typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+      typename B         = Allocator,
+      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,
@@ -58090,8 +58219,11 @@ namespace VULKAN_HPP_NAMESPACE
     std::vector<SparseImageFormatProperties2, Allocator>
       getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
                                        Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
-    template <typename Allocator = std::allocator<SparseImageFormatProperties2>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    template <
+      typename Allocator = std::allocator<SparseImageFormatProperties2>,
+      typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+      typename B         = Allocator,
+      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,
@@ -58110,8 +58242,11 @@ namespace VULKAN_HPP_NAMESPACE
     std::vector<SparseImageFormatProperties2, Allocator>
       getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
                                           Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
-    template <typename Allocator = std::allocator<SparseImageFormatProperties2>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    template <
+      typename Allocator = std::allocator<SparseImageFormatProperties2>,
+      typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+      typename B         = Allocator,
+      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,
@@ -58128,8 +58263,11 @@ namespace VULKAN_HPP_NAMESPACE
               typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<FramebufferMixedSamplesCombinationNV, Allocator>>::type
       getSupportedFramebufferMixedSamplesCombinationsNV( Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
-    template <typename Allocator = std::allocator<FramebufferMixedSamplesCombinationNV>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    template <typename Allocator                 = std::allocator<FramebufferMixedSamplesCombinationNV>,
+              typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B                         = Allocator,
+              typename std::enable_if<std::is_same<typename B::value_type, FramebufferMixedSamplesCombinationNV>::value,
+                                      int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<FramebufferMixedSamplesCombinationNV, Allocator>>::type
       getSupportedFramebufferMixedSamplesCombinationsNV( Allocator const & vectorAllocator, Dispatch const & d ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@@ -58189,7 +58327,9 @@ namespace VULKAN_HPP_NAMESPACE
       getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
                              Dispatch const &                      d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
     template <typename Allocator = std::allocator<SurfaceFormat2KHR>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B         = Allocator,
+              typename std::enable_if<std::is_same<typename B::value_type, SurfaceFormat2KHR>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<SurfaceFormat2KHR, Allocator>>::type
       getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
                              Allocator const &                     vectorAllocator,
@@ -58209,7 +58349,9 @@ namespace VULKAN_HPP_NAMESPACE
       getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
                             Dispatch const &                 d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
     template <typename Allocator = std::allocator<SurfaceFormatKHR>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B         = Allocator,
+              typename std::enable_if<std::is_same<typename B::value_type, SurfaceFormatKHR>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<SurfaceFormatKHR, Allocator>>::type getSurfaceFormatsKHR(
       VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Allocator const & vectorAllocator, Dispatch const & d ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@@ -58228,7 +58370,9 @@ namespace VULKAN_HPP_NAMESPACE
       getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
                                   Dispatch const &                      d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
     template <typename Allocator = std::allocator<PresentModeKHR>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B         = Allocator,
+              typename std::enable_if<std::is_same<typename B::value_type, PresentModeKHR>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PresentModeKHR, Allocator>>::type
       getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
                                   Allocator const &                     vectorAllocator,
@@ -58249,7 +58393,9 @@ namespace VULKAN_HPP_NAMESPACE
       getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
                                  Dispatch const &                 d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
     template <typename Allocator = std::allocator<PresentModeKHR>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B         = Allocator,
+              typename std::enable_if<std::is_same<typename B::value_type, PresentModeKHR>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PresentModeKHR, Allocator>>::type
       getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
                                  Allocator const &                vectorAllocator,
@@ -58280,8 +58426,11 @@ namespace VULKAN_HPP_NAMESPACE
               typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PhysicalDeviceToolPropertiesEXT, Allocator>>::type
       getToolPropertiesEXT( Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
-    template <typename Allocator = std::allocator<PhysicalDeviceToolPropertiesEXT>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    template <typename Allocator                 = std::allocator<PhysicalDeviceToolPropertiesEXT>,
+              typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B                         = Allocator,
+              typename std::enable_if<std::is_same<typename B::value_type, PhysicalDeviceToolPropertiesEXT>::value,
+                                      int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PhysicalDeviceToolPropertiesEXT, Allocator>>::type
       getToolPropertiesEXT( Allocator const & vectorAllocator, Dispatch const & d ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@@ -85410,8 +85559,11 @@ namespace VULKAN_HPP_NAMESPACE
               typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PhysicalDeviceGroupProperties, Allocator>>::type
       enumeratePhysicalDeviceGroups( Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
-    template <typename Allocator = std::allocator<PhysicalDeviceGroupProperties>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    template <typename Allocator                 = std::allocator<PhysicalDeviceGroupProperties>,
+              typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B                         = Allocator,
+              typename std::enable_if<std::is_same<typename B::value_type, PhysicalDeviceGroupProperties>::value,
+                                      int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PhysicalDeviceGroupProperties, Allocator>>::type
       enumeratePhysicalDeviceGroups( Allocator const & vectorAllocator, Dispatch const & d ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@@ -85426,8 +85578,11 @@ namespace VULKAN_HPP_NAMESPACE
               typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PhysicalDeviceGroupProperties, Allocator>>::type
       enumeratePhysicalDeviceGroupsKHR( Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
-    template <typename Allocator = std::allocator<PhysicalDeviceGroupProperties>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    template <typename Allocator                 = std::allocator<PhysicalDeviceGroupProperties>,
+              typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B                         = Allocator,
+              typename std::enable_if<std::is_same<typename B::value_type, PhysicalDeviceGroupProperties>::value,
+                                      int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PhysicalDeviceGroupProperties, Allocator>>::type
       enumeratePhysicalDeviceGroupsKHR( Allocator const & vectorAllocator, Dispatch const & d ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@@ -85443,7 +85598,9 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PhysicalDevice, Allocator>>::type
       enumeratePhysicalDevices( Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
     template <typename Allocator = std::allocator<PhysicalDevice>,
-              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+              typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename B         = Allocator,
+              typename std::enable_if<std::is_same<typename B::value_type, PhysicalDevice>::value, int>::type = 0>
     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PhysicalDevice, Allocator>>::type
       enumeratePhysicalDevices( Allocator const & vectorAllocator, Dispatch const & d ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@@ -85545,7 +85702,9 @@ namespace VULKAN_HPP_NAMESPACE
     enumerateInstanceExtensionProperties( Optional<const std::string> layerName = nullptr,
                                           Dispatch const &            d         = VULKAN_HPP_DEFAULT_DISPATCHER );
   template <typename Allocator = std::allocator<ExtensionProperties>,
-            typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+            typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+            typename B         = Allocator,
+            typename std::enable_if<std::is_same<typename B::value_type, ExtensionProperties>::value, int>::type = 0>
   VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<ExtensionProperties, Allocator>>::type
     enumerateInstanceExtensionProperties( Optional<const std::string> layerName,
                                           Allocator const &           vectorAllocator,
@@ -85563,7 +85722,9 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<LayerProperties, Allocator>>::type
     enumerateInstanceLayerProperties( Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER );
   template <typename Allocator = std::allocator<LayerProperties>,
-            typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+            typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+            typename B         = Allocator,
+            typename std::enable_if<std::is_same<typename B::value_type, LayerProperties>::value, int>::type = 0>
   VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<LayerProperties, Allocator>>::type
     enumerateInstanceLayerProperties( Allocator const & vectorAllocator, Dispatch const & d );
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@@ -85663,7 +85824,10 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValue(
       result, properties, VULKAN_HPP_NAMESPACE_STRING "::enumerateInstanceExtensionProperties" );
   }
-  template <typename Allocator, typename Dispatch>
+  template <typename Allocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, ExtensionProperties>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<ExtensionProperties, Allocator>>::type
                        enumerateInstanceExtensionProperties( Optional<const std::string> layerName,
                                                              Allocator const &           vectorAllocator,
@@ -85729,7 +85893,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
     return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING "::enumerateInstanceLayerProperties" );
   }
-  template <typename Allocator, typename Dispatch>
+  template <typename Allocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, LayerProperties>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<LayerProperties, Allocator>>::type
                        enumerateInstanceLayerProperties( Allocator const & vectorAllocator, Dispatch const & d )
   {
@@ -89137,7 +89304,10 @@ namespace VULKAN_HPP_NAMESPACE
                                   reinterpret_cast<VkCommandBuffer *>( commandBuffers.data() ) ) );
     return createResultValue( result, commandBuffers, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffers" );
   }
-  template <typename Allocator, typename Dispatch>
+  template <typename Allocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, CommandBuffer>::value, int>::type>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
     typename ResultValueType<std::vector<CommandBuffer, Allocator>>::type
     Device::allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo,
@@ -89152,7 +89322,7 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValue( result, commandBuffers, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffers" );
   }
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Allocator, typename Dispatch>
+  template <typename Dispatch, typename Allocator>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
     typename ResultValueType<std::vector<UniqueHandle<CommandBuffer, Dispatch>, Allocator>>::type
     Device::allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo, Dispatch const & d ) const
@@ -89176,7 +89346,11 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValue(
       result, std::move( uniqueCommandBuffers ), VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffersUnique" );
   }
-  template <typename Allocator, typename Dispatch>
+  template <typename Dispatch,
+            typename Allocator,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<CommandBuffer, Dispatch>>::value,
+                                    int>::type>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
     typename ResultValueType<std::vector<UniqueHandle<CommandBuffer, Dispatch>, Allocator>>::type
     Device::allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo,
@@ -89229,7 +89403,10 @@ namespace VULKAN_HPP_NAMESPACE
                                   reinterpret_cast<VkDescriptorSet *>( descriptorSets.data() ) ) );
     return createResultValue( result, descriptorSets, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSets" );
   }
-  template <typename Allocator, typename Dispatch>
+  template <typename Allocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, DescriptorSet>::value, int>::type>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
     typename ResultValueType<std::vector<DescriptorSet, Allocator>>::type
     Device::allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo,
@@ -89244,7 +89421,7 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValue( result, descriptorSets, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSets" );
   }
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Allocator, typename Dispatch>
+  template <typename Dispatch, typename Allocator>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
     typename ResultValueType<std::vector<UniqueHandle<DescriptorSet, Dispatch>, Allocator>>::type
     Device::allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo, Dispatch const & d ) const
@@ -89268,7 +89445,11 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValue(
       result, std::move( uniqueDescriptorSets ), VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSetsUnique" );
   }
-  template <typename Allocator, typename Dispatch>
+  template <typename Dispatch,
+            typename Allocator,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<DescriptorSet, Dispatch>>::value,
+                                    int>::type>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
     typename ResultValueType<std::vector<UniqueHandle<DescriptorSet, Dispatch>, Allocator>>::type
     Device::allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo,
@@ -89962,7 +90143,10 @@ namespace VULKAN_HPP_NAMESPACE
                               VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelines",
                               { Result::eSuccess, Result::ePipelineCompileRequiredEXT } );
   }
-  template <typename Allocator, typename Dispatch>
+  template <typename Allocator,
+            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, Allocator>> Device::createComputePipelines(
     VULKAN_HPP_NAMESPACE::PipelineCache                                       pipelineCache,
     ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos,
@@ -90004,7 +90188,7 @@ namespace VULKAN_HPP_NAMESPACE
                               { Result::eSuccess, Result::ePipelineCompileRequiredEXT } );
   }
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Allocator, typename Dispatch>
+  template <typename Dispatch, typename Allocator>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator>>
                                          Device::createComputePipelinesUnique(
       VULKAN_HPP_NAMESPACE::PipelineCache                                       pipelineCache,
@@ -90038,7 +90222,11 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelinesUnique",
       { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
   }
-  template <typename Allocator, typename Dispatch>
+  template <
+    typename Dispatch,
+    typename Allocator,
+    typename B,
+    typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator>>
                                          Device::createComputePipelinesUnique(
       VULKAN_HPP_NAMESPACE::PipelineCache                                       pipelineCache,
@@ -90541,7 +90729,10 @@ namespace VULKAN_HPP_NAMESPACE
                               VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelines",
                               { Result::eSuccess, Result::ePipelineCompileRequiredEXT } );
   }
-  template <typename Allocator, typename Dispatch>
+  template <typename Allocator,
+            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, Allocator>> Device::createGraphicsPipelines(
     VULKAN_HPP_NAMESPACE::PipelineCache                                        pipelineCache,
     ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
@@ -90583,7 +90774,7 @@ namespace VULKAN_HPP_NAMESPACE
                               { Result::eSuccess, Result::ePipelineCompileRequiredEXT } );
   }
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Allocator, typename Dispatch>
+  template <typename Dispatch, typename Allocator>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator>>
                                          Device::createGraphicsPipelinesUnique(
       VULKAN_HPP_NAMESPACE::PipelineCache                                        pipelineCache,
@@ -90617,7 +90808,11 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelinesUnique",
       { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
   }
-  template <typename Allocator, typename Dispatch>
+  template <
+    typename Dispatch,
+    typename Allocator,
+    typename B,
+    typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator>>
                                          Device::createGraphicsPipelinesUnique(
       VULKAN_HPP_NAMESPACE::PipelineCache                                        pipelineCache,
@@ -91077,7 +91272,10 @@ namespace VULKAN_HPP_NAMESPACE
                                 Result::eOperationNotDeferredKHR,
                                 Result::ePipelineCompileRequiredEXT } );
   }
-  template <typename Allocator, typename Dispatch>
+  template <typename Allocator,
+            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, Allocator>>
                                          Device::createRayTracingPipelinesKHR(
       VULKAN_HPP_NAMESPACE::PipelineCache                                             pipelineCache,
@@ -91126,7 +91324,7 @@ namespace VULKAN_HPP_NAMESPACE
                                 Result::ePipelineCompileRequiredEXT } );
   }
 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Allocator, typename Dispatch>
+  template <typename Dispatch, typename Allocator>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator>>
                                          Device::createRayTracingPipelinesKHRUnique(
       VULKAN_HPP_NAMESPACE::PipelineCache                                             pipelineCache,
@@ -91164,7 +91362,11 @@ namespace VULKAN_HPP_NAMESPACE
                                 VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR,
                                 VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
   }
-  template <typename Allocator, typename Dispatch>
+  template <
+    typename Dispatch,
+    typename Allocator,
+    typename B,
+    typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator>>
                                          Device::createRayTracingPipelinesKHRUnique(
       VULKAN_HPP_NAMESPACE::PipelineCache                                             pipelineCache,
@@ -91273,7 +91475,10 @@ namespace VULKAN_HPP_NAMESPACE
                               VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNV",
                               { Result::eSuccess, Result::ePipelineCompileRequiredEXT } );
   }
-  template <typename Allocator, typename Dispatch>
+  template <typename Allocator,
+            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, Allocator>>
                                          Device::createRayTracingPipelinesNV(
       VULKAN_HPP_NAMESPACE::PipelineCache                                            pipelineCache,
@@ -91316,7 +91521,7 @@ namespace VULKAN_HPP_NAMESPACE
                               { Result::eSuccess, Result::ePipelineCompileRequiredEXT } );
   }
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Allocator, typename Dispatch>
+  template <typename Dispatch, typename Allocator>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator>>
                                          Device::createRayTracingPipelinesNVUnique(
       VULKAN_HPP_NAMESPACE::PipelineCache                                            pipelineCache,
@@ -91350,7 +91555,11 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNVUnique",
       { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
   }
-  template <typename Allocator, typename Dispatch>
+  template <
+    typename Dispatch,
+    typename Allocator,
+    typename B,
+    typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator>>
                                          Device::createRayTracingPipelinesNVUnique(
       VULKAN_HPP_NAMESPACE::PipelineCache                                            pipelineCache,
@@ -91851,7 +92060,10 @@ namespace VULKAN_HPP_NAMESPACE
       reinterpret_cast<VkSwapchainKHR *>( swapchains.data() ) ) );
     return createResultValue( result, swapchains, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHR" );
   }
-  template <typename Allocator, typename Dispatch>
+  template <typename Allocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, SwapchainKHR>::value, int>::type>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
     typename ResultValueType<std::vector<SwapchainKHR, Allocator>>::type
     Device::createSharedSwapchainsKHR(
@@ -91885,7 +92097,7 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValue( result, swapchain, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainKHR" );
   }
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Allocator, typename Dispatch>
+  template <typename Dispatch, typename Allocator>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
     typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR, Dispatch>, Allocator>>::type
     Device::createSharedSwapchainsKHRUnique(
@@ -91915,7 +92127,11 @@ namespace VULKAN_HPP_NAMESPACE
                               std::move( uniqueSwapchainKHRs ),
                               VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHRUnique" );
   }
-  template <typename Allocator, typename Dispatch>
+  template <typename Dispatch,
+            typename Allocator,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<SwapchainKHR, Dispatch>>::value,
+                                    int>::type>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
     typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR, Dispatch>, Allocator>>::type
     Device::createSharedSwapchainsKHRUnique(
@@ -94627,7 +94843,11 @@ namespace VULKAN_HPP_NAMESPACE
       reinterpret_cast<VkSparseImageMemoryRequirements *>( sparseMemoryRequirements.data() ) );
     return sparseMemoryRequirements;
   }
-  template <typename Allocator, typename Dispatch>
+  template <
+    typename Allocator,
+    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
   {
@@ -94678,7 +94898,11 @@ namespace VULKAN_HPP_NAMESPACE
       reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) );
     return sparseMemoryRequirements;
   }
-  template <typename Allocator, typename Dispatch>
+  template <
+    typename Allocator,
+    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
   {
@@ -94731,7 +94955,11 @@ namespace VULKAN_HPP_NAMESPACE
       reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) );
     return sparseMemoryRequirements;
   }
-  template <typename Allocator, typename Dispatch>
+  template <
+    typename Allocator,
+    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
   {
@@ -95058,7 +95286,11 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValue(
       result, presentationTimings, VULKAN_HPP_NAMESPACE_STRING "::Device::getPastPresentationTimingGOOGLE" );
   }
-  template <typename Allocator, typename Dispatch>
+  template <
+    typename Allocator,
+    typename Dispatch,
+    typename B,
+    typename std::enable_if<std::is_same<typename B::value_type, PastPresentationTimingGOOGLE>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
     typename ResultValueType<std::vector<PastPresentationTimingGOOGLE, Allocator>>::type
     Device::getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
@@ -95157,7 +95389,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
     return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineCacheData" );
   }
-  template <typename Allocator, typename Dispatch>
+  template <typename Allocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, uint8_t>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t, Allocator>>::type
                        Device::getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
                                   Allocator const &                   vectorAllocator,
@@ -95237,7 +95472,12 @@ namespace VULKAN_HPP_NAMESPACE
                               internalRepresentations,
                               VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutableInternalRepresentationsKHR" );
   }
-  template <typename Allocator, typename Dispatch>
+  template <
+    typename Allocator,
+    typename Dispatch,
+    typename B,
+    typename std::enable_if<std::is_same<typename B::value_type, PipelineExecutableInternalRepresentationKHR>::value,
+                            int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
     typename ResultValueType<std::vector<PipelineExecutableInternalRepresentationKHR, Allocator>>::type
     Device::getPipelineExecutableInternalRepresentationsKHR( const PipelineExecutableInfoKHR & executableInfo,
@@ -95319,7 +95559,11 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValue(
       result, properties, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutablePropertiesKHR" );
   }
-  template <typename Allocator, typename Dispatch>
+  template <
+    typename Allocator,
+    typename Dispatch,
+    typename B,
+    typename std::enable_if<std::is_same<typename B::value_type, PipelineExecutablePropertiesKHR>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
     typename ResultValueType<std::vector<PipelineExecutablePropertiesKHR, Allocator>>::type
     Device::getPipelineExecutablePropertiesKHR( const PipelineInfoKHR & pipelineInfo,
@@ -95401,7 +95645,11 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValue(
       result, statistics, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutableStatisticsKHR" );
   }
-  template <typename Allocator, typename Dispatch>
+  template <
+    typename Allocator,
+    typename Dispatch,
+    typename B,
+    typename std::enable_if<std::is_same<typename B::value_type, PipelineExecutableStatisticKHR>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
     typename ResultValueType<std::vector<PipelineExecutableStatisticKHR, Allocator>>::type
     Device::getPipelineExecutableStatisticsKHR( const PipelineExecutableInfoKHR & executableInfo,
@@ -95797,7 +96045,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
     return createResultValue( result, info, VULKAN_HPP_NAMESPACE_STRING "::Device::getShaderInfoAMD" );
   }
-  template <typename Allocator, typename Dispatch>
+  template <typename Allocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, uint8_t>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t, Allocator>>::type
                        Device::getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline            pipeline,
                               VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage,
@@ -95906,7 +96157,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
     return createResultValue( result, swapchainImages, VULKAN_HPP_NAMESPACE_STRING "::Device::getSwapchainImagesKHR" );
   }
-  template <typename Allocator, typename Dispatch>
+  template <typename Allocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, Image>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<Image, Allocator>>::type
                        Device::getSwapchainImagesKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
                                    Allocator const &                  vectorAllocator,
@@ -95998,7 +96252,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
     return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getValidationCacheDataEXT" );
   }
-  template <typename Allocator, typename Dispatch>
+  template <typename Allocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, uint8_t>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t, Allocator>>::type
                        Device::getValidationCacheDataEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache,
                                        Allocator const &                        vectorAllocator,
@@ -98049,7 +98306,11 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValue(
       result, physicalDeviceGroupProperties, VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDeviceGroups" );
   }
-  template <typename Allocator, typename Dispatch>
+  template <
+    typename Allocator,
+    typename Dispatch,
+    typename B,
+    typename std::enable_if<std::is_same<typename B::value_type, PhysicalDeviceGroupProperties>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
     typename ResultValueType<std::vector<PhysicalDeviceGroupProperties, Allocator>>::type
     Instance::enumeratePhysicalDeviceGroups( Allocator const & vectorAllocator, Dispatch const & d ) const
@@ -98122,7 +98383,11 @@ namespace VULKAN_HPP_NAMESPACE
                               physicalDeviceGroupProperties,
                               VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDeviceGroupsKHR" );
   }
-  template <typename Allocator, typename Dispatch>
+  template <
+    typename Allocator,
+    typename Dispatch,
+    typename B,
+    typename std::enable_if<std::is_same<typename B::value_type, PhysicalDeviceGroupProperties>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
     typename ResultValueType<std::vector<PhysicalDeviceGroupProperties, Allocator>>::type
     Instance::enumeratePhysicalDeviceGroupsKHR( Allocator const & vectorAllocator, Dispatch const & d ) const
@@ -98189,7 +98454,10 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValue(
       result, physicalDevices, VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDevices" );
   }
-  template <typename Allocator, typename Dispatch>
+  template <typename Allocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, PhysicalDevice>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<PhysicalDevice, Allocator>>::type
                        Instance::enumeratePhysicalDevices( Allocator const & vectorAllocator, Dispatch const & d ) const
   {
@@ -98404,7 +98672,10 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValue(
       result, properties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateDeviceExtensionProperties" );
   }
-  template <typename Allocator, typename Dispatch>
+  template <typename Allocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, ExtensionProperties>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<ExtensionProperties, Allocator>>::type
                        PhysicalDevice::enumerateDeviceExtensionProperties( Optional<const std::string> layerName,
                                                         Allocator const &           vectorAllocator,
@@ -98472,7 +98743,10 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValue(
       result, properties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateDeviceLayerProperties" );
   }
-  template <typename Allocator, typename Dispatch>
+  template <typename Allocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, LayerProperties>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<LayerProperties, Allocator>>::type
                        PhysicalDevice::enumerateDeviceLayerProperties( Allocator const & vectorAllocator, Dispatch const & d ) const
   {
@@ -98555,7 +98829,11 @@ namespace VULKAN_HPP_NAMESPACE
                               VULKAN_HPP_NAMESPACE_STRING
                               "::PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR" );
   }
-  template <typename Allocator, typename Dispatch>
+  template <
+    typename Allocator,
+    typename Dispatch,
+    typename B,
+    typename std::enable_if<std::is_same<typename B::value_type, PerformanceCounterDescriptionKHR>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
     typename ResultValueType<std::vector<PerformanceCounterDescriptionKHR, Allocator>>::type
     PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR(
@@ -98642,7 +98920,10 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValue(
       result, properties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayModeProperties2KHR" );
   }
-  template <typename Allocator, typename Dispatch>
+  template <typename Allocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, DisplayModeProperties2KHR>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
     typename ResultValueType<std::vector<DisplayModeProperties2KHR, Allocator>>::type
     PhysicalDevice::getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR display,
@@ -98720,7 +99001,10 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValue(
       result, properties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayModePropertiesKHR" );
   }
-  template <typename Allocator, typename Dispatch>
+  template <typename Allocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, DisplayModePropertiesKHR>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
     typename ResultValueType<std::vector<DisplayModePropertiesKHR, Allocator>>::type
     PhysicalDevice::getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display,
@@ -98851,7 +99135,10 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValue(
       result, displays, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR" );
   }
-  template <typename Allocator, typename Dispatch>
+  template <typename Allocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, DisplayKHR>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayKHR, Allocator>>::type
                        PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR( uint32_t          planeIndex,
                                                          Allocator const & vectorAllocator,
@@ -98917,7 +99204,10 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValue(
       result, timeDomains, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCalibrateableTimeDomainsEXT" );
   }
-  template <typename Allocator, typename Dispatch>
+  template <typename Allocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, TimeDomainEXT>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<TimeDomainEXT, Allocator>>::type
                        PhysicalDevice::getCalibrateableTimeDomainsEXT( Allocator const & vectorAllocator, Dispatch const & d ) const
   {
@@ -98984,7 +99274,11 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValue(
       result, properties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCooperativeMatrixPropertiesNV" );
   }
-  template <typename Allocator, typename Dispatch>
+  template <
+    typename Allocator,
+    typename Dispatch,
+    typename B,
+    typename std::enable_if<std::is_same<typename B::value_type, CooperativeMatrixPropertiesNV>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
     typename ResultValueType<std::vector<CooperativeMatrixPropertiesNV, Allocator>>::type
     PhysicalDevice::getCooperativeMatrixPropertiesNV( Allocator const & vectorAllocator, Dispatch const & d ) const
@@ -99070,7 +99364,10 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValue(
       result, properties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneProperties2KHR" );
   }
-  template <typename Allocator, typename Dispatch>
+  template <typename Allocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, DisplayPlaneProperties2KHR>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
     typename ResultValueType<std::vector<DisplayPlaneProperties2KHR, Allocator>>::type
     PhysicalDevice::getDisplayPlaneProperties2KHR( Allocator const & vectorAllocator, Dispatch const & d ) const
@@ -99136,7 +99433,10 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValue(
       result, properties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlanePropertiesKHR" );
   }
-  template <typename Allocator, typename Dispatch>
+  template <typename Allocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, DisplayPlanePropertiesKHR>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
     typename ResultValueType<std::vector<DisplayPlanePropertiesKHR, Allocator>>::type
     PhysicalDevice::getDisplayPlanePropertiesKHR( Allocator const & vectorAllocator, Dispatch const & d ) const
@@ -99201,7 +99501,10 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValue(
       result, properties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayProperties2KHR" );
   }
-  template <typename Allocator, typename Dispatch>
+  template <typename Allocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, DisplayProperties2KHR>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayProperties2KHR, Allocator>>::type
                        PhysicalDevice::getDisplayProperties2KHR( Allocator const & vectorAllocator, Dispatch const & d ) const
   {
@@ -99265,7 +99568,10 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValue(
       result, properties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPropertiesKHR" );
   }
-  template <typename Allocator, typename Dispatch>
+  template <typename Allocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, DisplayPropertiesKHR>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayPropertiesKHR, Allocator>>::type
                        PhysicalDevice::getDisplayPropertiesKHR( Allocator const & vectorAllocator, Dispatch const & d ) const
   {
@@ -99936,7 +100242,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
     return createResultValue( result, rects, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getPresentRectanglesKHR" );
   }
-  template <typename Allocator, typename Dispatch>
+  template <typename Allocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, Rect2D>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<Rect2D, Allocator>>::type
                        PhysicalDevice::getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
                                              Allocator const &                vectorAllocator,
@@ -100096,7 +100405,10 @@ namespace VULKAN_HPP_NAMESPACE
       reinterpret_cast<VkQueueFamilyProperties *>( queueFamilyProperties.data() ) );
     return queueFamilyProperties;
   }
-  template <typename Allocator, typename Dispatch>
+  template <typename Allocator,
+            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
   {
@@ -100138,7 +100450,10 @@ namespace VULKAN_HPP_NAMESPACE
       reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) );
     return queueFamilyProperties;
   }
-  template <typename Allocator, typename Dispatch>
+  template <typename Allocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, QueueFamilyProperties2>::value, int>::type>
   VULKAN_HPP_INLINE std::vector<QueueFamilyProperties2, Allocator>
                     PhysicalDevice::getQueueFamilyProperties2( Allocator const & vectorAllocator, Dispatch const & d ) const
   {
@@ -100174,7 +100489,11 @@ namespace VULKAN_HPP_NAMESPACE
     }
     return queueFamilyProperties;
   }
-  template <typename StructureChain, typename Allocator, typename Dispatch>
+  template <typename StructureChain,
+            typename Allocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, StructureChain>::value, int>::type>
   VULKAN_HPP_INLINE std::vector<StructureChain, Allocator>
                     PhysicalDevice::getQueueFamilyProperties2( Allocator const & vectorAllocator, Dispatch const & d ) const
   {
@@ -100224,7 +100543,10 @@ namespace VULKAN_HPP_NAMESPACE
       reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) );
     return queueFamilyProperties;
   }
-  template <typename Allocator, typename Dispatch>
+  template <typename Allocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, QueueFamilyProperties2>::value, int>::type>
   VULKAN_HPP_INLINE std::vector<QueueFamilyProperties2, Allocator>
                     PhysicalDevice::getQueueFamilyProperties2KHR( Allocator const & vectorAllocator, Dispatch const & d ) const
   {
@@ -100260,7 +100582,11 @@ namespace VULKAN_HPP_NAMESPACE
     }
     return queueFamilyProperties;
   }
-  template <typename StructureChain, typename Allocator, typename Dispatch>
+  template <typename StructureChain,
+            typename Allocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, StructureChain>::value, int>::type>
   VULKAN_HPP_INLINE std::vector<StructureChain, Allocator>
                     PhysicalDevice::getQueueFamilyProperties2KHR( Allocator const & vectorAllocator, Dispatch const & d ) const
   {
@@ -100337,7 +100663,11 @@ namespace VULKAN_HPP_NAMESPACE
       reinterpret_cast<VkSparseImageFormatProperties *>( properties.data() ) );
     return properties;
   }
-  template <typename Allocator, typename Dispatch>
+  template <
+    typename Allocator,
+    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_NAMESPACE::ImageType           type,
@@ -100405,7 +100735,11 @@ namespace VULKAN_HPP_NAMESPACE
       reinterpret_cast<VkSparseImageFormatProperties2 *>( properties.data() ) );
     return properties;
   }
-  template <typename Allocator, typename Dispatch>
+  template <
+    typename Allocator,
+    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,
@@ -100462,7 +100796,11 @@ namespace VULKAN_HPP_NAMESPACE
       reinterpret_cast<VkSparseImageFormatProperties2 *>( properties.data() ) );
     return properties;
   }
-  template <typename Allocator, typename Dispatch>
+  template <
+    typename Allocator,
+    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,
@@ -100528,7 +100866,11 @@ namespace VULKAN_HPP_NAMESPACE
                               VULKAN_HPP_NAMESPACE_STRING
                               "::PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV" );
   }
-  template <typename Allocator, typename Dispatch>
+  template <typename Allocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, FramebufferMixedSamplesCombinationNV>::value,
+                                    int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
     typename ResultValueType<std::vector<FramebufferMixedSamplesCombinationNV, Allocator>>::type
     PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV( Allocator const & vectorAllocator,
@@ -100705,7 +101047,10 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValue(
       result, surfaceFormats, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceFormats2KHR" );
   }
-  template <typename Allocator, typename Dispatch>
+  template <typename Allocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, SurfaceFormat2KHR>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<SurfaceFormat2KHR, Allocator>>::type
                        PhysicalDevice::getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
                                            Allocator const &                     vectorAllocator,
@@ -100784,7 +101129,10 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValue(
       result, surfaceFormats, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceFormatsKHR" );
   }
-  template <typename Allocator, typename Dispatch>
+  template <typename Allocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, SurfaceFormatKHR>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<SurfaceFormatKHR, Allocator>>::type
                        PhysicalDevice::getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
                                           Allocator const &                vectorAllocator,
@@ -100865,7 +101213,10 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValue(
       result, presentModes, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfacePresentModes2EXT" );
   }
-  template <typename Allocator, typename Dispatch>
+  template <typename Allocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, PresentModeKHR>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<PresentModeKHR, Allocator>>::type
                        PhysicalDevice::getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
                                                 Allocator const &                     vectorAllocator,
@@ -100945,7 +101296,10 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValue(
       result, presentModes, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfacePresentModesKHR" );
   }
-  template <typename Allocator, typename Dispatch>
+  template <typename Allocator,
+            typename Dispatch,
+            typename B,
+            typename std::enable_if<std::is_same<typename B::value_type, PresentModeKHR>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<PresentModeKHR, Allocator>>::type
                        PhysicalDevice::getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
                                                Allocator const &                vectorAllocator,
@@ -101045,7 +101399,11 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValue(
       result, toolProperties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getToolPropertiesEXT" );
   }
-  template <typename Allocator, typename Dispatch>
+  template <
+    typename Allocator,
+    typename Dispatch,
+    typename B,
+    typename std::enable_if<std::is_same<typename B::value_type, PhysicalDeviceToolPropertiesEXT>::value, int>::type>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
     typename ResultValueType<std::vector<PhysicalDeviceToolPropertiesEXT, Allocator>>::type
     PhysicalDevice::getToolPropertiesEXT( Allocator const & vectorAllocator, Dispatch const & d ) const
@@ -101218,7 +101576,10 @@ namespace VULKAN_HPP_NAMESPACE
       m_queue, &checkpointDataCount, reinterpret_cast<VkCheckpointDataNV *>( checkpointData.data() ) );
     return checkpointData;
   }
-  template <typename Allocator, typename Dispatch>
+  template <typename Allocator,
+            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
   {