Sort handle classes by feature and extension. (#1500)

VulkanHppGenerator.cpp

@@ -193,14 +193,19 @@ void VulkanHppGenerator::generateVulkanHandlesHppFile() const
 namespace VULKAN_HPP_NAMESPACE
 {
 ${structForwardDeclarations}
+${handleForwardDeclarations}
+${uniqueHandles}
 ${handles}
 }   // namespace VULKAN_HPP_NAMESPACE
 #endif
 )";
 
-  std::string str = replaceWithMap(
+  std::string str = replaceWithMap( vulkanHandlesHppTemplate,
-    vulkanHandlesHppTemplate,
+                                    { { "handles", generateHandles() },
-    { { "handles", generateHandles() }, { "licenseHeader", m_vulkanLicenseHeader }, { "structForwardDeclarations", generateStructForwardDeclarations() } } );
+                                      { "handleForwardDeclarations", generateHandleForwardDeclarations() },
+                                      { "licenseHeader", m_vulkanLicenseHeader },
+                                      { "structForwardDeclarations", generateStructForwardDeclarations() },
+                                      { "uniqueHandles", generateUniqueHandles() } } );
 
   writeToFile( str, vulkan_handles_hpp );
 }
@@ -545,7 +550,7 @@ void VulkanHppGenerator::addCommand( std::string const & name, CommandData & com
 {
   // find the handle this command is going to be associated to
   checkForError( !commandData.params.empty(), commandData.xmlLine, "command <" + name + "> with no params" );
-  std::map<std::string, HandleData>::iterator handleIt = m_handles.find( commandData.params[0].type.type );
+  auto handleIt = m_handles.find( commandData.params[0].type.type );
   if ( handleIt == m_handles.end() )
   {
     handleIt = m_handles.begin();
@@ -5626,17 +5631,6 @@ std::string VulkanHppGenerator::generateHandle( std::pair<std::string, HandleDat
   }
   else
   {
-    // append any forward declaration of Deleters used by this handle
-    if ( !handleData.second.childrenHandles.empty() )
-    {
-      str += generateUniqueTypes( handleData.first, handleData.second.childrenHandles );
-    }
-    else if ( handleData.first == "VkPhysicalDevice" )
-    {
-      // special handling for class Device, as it's created from PhysicalDevice, but destroys itself
-      str += generateUniqueTypes( "", { "VkDevice" } );
-    }
-
     // list all the commands that are mapped to members of this class
     std::string commands = generateHandleCommandDeclarations( handleData.second.commands );
 
@@ -5867,21 +5861,7 @@ std::string VulkanHppGenerator::generateHandleEmpty( HandleData const & handleDa
       {
         auto commandIt = m_commands.find( command );
         assert( commandIt != m_commands.end() );
-        if ( commandIt->first == "vkCreateInstance" )
+        str += "\n" + generateCommand( commandIt->first, commandIt->second, 0, false, false );
-        {
-          // special handling for createInstance, as we need to explicitly place the forward declarations and the
-          // deleter classes here
-#if !defined( NDEBUG )
-          auto handleIt = m_handles.find( "" );
-          assert( ( handleIt != m_handles.end() ) && ( handleIt->second.childrenHandles.size() == 2 ) );
-          assert( handleIt->second.childrenHandles.find( "VkInstance" ) != handleIt->second.childrenHandles.end() );
-#endif
-
-          str += generateUniqueTypes( "", { "VkInstance" } );
-        }
-        str += "\n";
-
-        str += generateCommand( commandIt->first, commandIt->second, 0, false, false );
       }
     }
   }
@@ -5894,6 +5874,46 @@ std::string VulkanHppGenerator::generateHandleEmpty( HandleData const & handleDa
   return str;
 }
 
+std::string VulkanHppGenerator::generateHandleForwardDeclarations() const
+{
+  const std::string fowardDeclarationsTemplate = R"(
+  //===================================
+  //=== HANDLE forward declarations ===
+  //===================================
+
+${forwardDeclarations}
+)";
+
+  std::string forwardDeclarations;
+  for ( auto const & feature : m_features )
+  {
+    forwardDeclarations += generateHandleForwardDeclarations( feature.second.requireData, feature.first );
+  }
+  for ( auto const & extIt : m_extensionsByNumber )
+  {
+    forwardDeclarations += generateHandleForwardDeclarations( extIt.second->second.requireData, extIt.second->first );
+  }
+
+  return replaceWithMap( fowardDeclarationsTemplate, { { "forwardDeclarations", forwardDeclarations } } );
+}
+
+std::string VulkanHppGenerator::generateHandleForwardDeclarations( std::vector<RequireData> const & requireData, std::string const & title ) const
+{
+  std::string str;
+  for ( auto const & require : requireData )
+  {
+    for ( auto const & type : require.types )
+    {
+      auto handleIt = m_handles.find( type );
+      if ( handleIt != m_handles.end() )
+      {
+        str += "class " + stripPrefix( handleIt->first, "Vk" ) + ";\n";
+      }
+    }
+  }
+  return addTitleAndProtection( title, str );
+}
+
 std::string VulkanHppGenerator::generateHandleHashStructures( std::vector<RequireData> const & requireData, std::string const & title ) const
 {
   const std::string hashTemplate = R"(
@@ -9806,56 +9826,81 @@ ${leave})";
     { { "constructors", constructors }, { "enter", enter }, { "leave", leave }, { "members", members }, { "setters", setters }, { "unionName", unionName } } );
 }
 
-std::string VulkanHppGenerator::generateUniqueTypes( std::string const & parentType, std::set<std::string> const & childrenTypes ) const
+std::string VulkanHppGenerator::generateUniqueHandle( std::pair<std::string, HandleData> const & handleData ) const
 {
-  std::string childrenTraits;
+  if ( !handleData.second.deleteCommand.empty() )
-  for ( auto const & childType : childrenTypes )
   {
-    auto handleIt = m_handles.find( childType );
+    std::string type = stripPrefix( handleData.first, "Vk" );
-    assert( handleIt != m_handles.end() );
-
-    std::string type = stripPrefix( childType, "Vk" );
-
-    auto [enter, leave] = generateProtection( handleIt->second.alias.empty() ? getProtectFromType( handleIt->first ) : "" );
-
     std::string aliasHandle;
-    if ( !handleIt->second.alias.empty() )
+    if ( !handleData.second.alias.empty() )
     {
       static const std::string aliasHandleTemplate =
-        R"(  using Unique${aliasType} = UniqueHandle<${type}, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
+        R"(  using Unique${aliasType} = UniqueHandle<${type}, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;)";
-)";
 
-      aliasHandle += replaceWithMap( aliasHandleTemplate, { { "aliasType", stripPrefix( handleIt->second.alias, "Vk" ) }, { "type", type } } );
+      aliasHandle += replaceWithMap( aliasHandleTemplate, { { "aliasType", stripPrefix( handleData.second.alias, "Vk" ) }, { "type", type } } );
     }
 
-    static const std::string traitsTemplate = R"(${enter}  template <typename Dispatch>
+    static const std::string uniqueHandleTemplate = R"(  template <typename Dispatch>
   class UniqueHandleTraits<${type}, Dispatch>
   {
   public:
     using deleter = ${deleterType}${deleterAction}<${deleterParent}${deleterPool}, Dispatch>;
   };
   using Unique${type} = UniqueHandle<${type}, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
-${aliasHandle}${leave})";
+${aliasHandle})";
 
-    childrenTraits += replaceWithMap( traitsTemplate,
+    return replaceWithMap( uniqueHandleTemplate,
-                                      { { "aliasHandle", aliasHandle },
+                           { { "aliasHandle", aliasHandle },
-                                        { "deleterAction", ( handleIt->second.deleteCommand.substr( 2, 4 ) == "Free" ) ? "Free" : "Destroy" },
+                             { "deleterAction", ( handleData.second.deleteCommand.substr( 2, 4 ) == "Free" ) ? "Free" : "Destroy" },
-                                        { "deleterParent", parentType.empty() ? "NoParent" : stripPrefix( parentType, "Vk" ) },
+                             { "deleterParent", handleData.second.deleteParent.empty() ? "NoParent" : stripPrefix(handleData.second.deleteParent, "Vk" ) },
-                                        { "deleterPool", handleIt->second.deletePool.empty() ? "" : ", " + stripPrefix( handleIt->second.deletePool, "Vk" ) },
+                             { "deleterPool", handleData.second.deletePool.empty() ? "" : ", " + stripPrefix( handleData.second.deletePool, "Vk" ) },
-                                        { "deleterType", handleIt->second.deletePool.empty() ? "Object" : "Pool" },
+                             { "deleterType", handleData.second.deletePool.empty() ? "Object" : "Pool" },
-                                        { "enter", enter },
+                             { "type", type } } );
-                                        { "leave", leave },
-                                        { "type", type } } );
   }
+  return "";
+}
 
-  static const std::string uniqueTypeTemplate = R"(
+std::string VulkanHppGenerator::generateUniqueHandle( std::vector<RequireData> const & requireData, std::string const & title ) const
+{
+  std::string str;
+  for ( auto const & require : requireData )
+  {
+    for ( auto const & type : require.types )
+    {
+      auto handleIt = m_handles.find( type );
+      if ( handleIt != m_handles.end() )
+      {
+        str += generateUniqueHandle( *handleIt );
+      }
+    }
+  }
+  return addTitleAndProtection( title, str );
+}
+
+std::string VulkanHppGenerator::generateUniqueHandles() const
+{
+  std::string uniqueHandlesTemplate = R"(
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
-${parentClass}${childrenTraits}#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+  //======================
+  //=== UNIQUE HANDLEs ===
+  //======================
+
+${uniqueHandles}
+#endif  /*VULKAN_HPP_NO_SMART_HANDLE*/
 )";
 
-  return replaceWithMap(
+  std::string uniqueHandles;
-    uniqueTypeTemplate,
+  for ( auto const & feature : m_features )
-    { { "childrenTraits", childrenTraits }, { "parentClass", parentType.empty() ? "" : ( "  class " + stripPrefix( parentType, "Vk" ) + ";\n" ) } } );
+  {
+    uniqueHandles += generateUniqueHandle( feature.second.requireData, feature.first );
+  }
+  for ( auto const & extIt : m_extensionsByNumber )
+  {
+    uniqueHandles += generateUniqueHandle( extIt.second->second.requireData, extIt.second->first );
+  }
+  assert( uniqueHandles.back() == '\n');
+  uniqueHandles.pop_back();
+  return replaceWithMap( uniqueHandlesTemplate, { { "uniqueHandles", uniqueHandles } } );
 }
 
 std::string VulkanHppGenerator::generateVectorSizeCheck( std::string const &                           name,
@@ -12837,6 +12882,7 @@ void VulkanHppGenerator::registerDeleter( std::string const & name, std::pair<st
     auto handleIt = m_handles.find( commandData.second.params[valueIndex].type.type );
     assert( handleIt != m_handles.end() );
     handleIt->second.deleteCommand = name;
+    handleIt->second.deleteParent = key;
   }
 }
 

VulkanHppGenerator.hpp

@@ -339,6 +339,7 @@ private:
     std::set<std::string> childrenHandles;
     std::set<std::string> commands;
     std::string           deleteCommand;
+    std::string           deleteParent;
     std::string           deletePool;
     std::string           objTypeEnum;
     std::string           parent;
@@ -717,6 +718,8 @@ private:
   std::string generateHandleCommandDeclarations( std::set<std::string> const & commands ) const;
   std::string generateHandleDependencies( std::pair<std::string, HandleData> const & handle, std::set<std::string> & listedHandles ) const;
   std::string generateHandleEmpty( HandleData const & handleData ) const;
+  std::string generateHandleForwardDeclarations() const;
+  std::string generateHandleForwardDeclarations( std::vector<RequireData> const & requireData, std::string const & title ) const;
   std::string generateHandleHashStructures( std::vector<RequireData> const & requireData, std::string const & title ) const;
   std::string generateHandleHashStructures() const;
   std::string generateHandles() const;
@@ -889,7 +892,9 @@ private:
                                                              std::vector<std::string> const &          dataTypes,
                                                              CommandFlavourFlags                       flavourFlags ) const;
   std::string                         generateUnion( std::pair<std::string, StructureData> const & structure ) const;
-  std::string                         generateUniqueTypes( std::string const & parentType, std::set<std::string> const & childrenTypes ) const;
+  std::string                         generateUniqueHandle( std::pair<std::string, HandleData> const & handleData ) const;
+  std::string                         generateUniqueHandle( std::vector<RequireData> const & requireData, std::string const & title ) const;
+  std::string                         generateUniqueHandles() const;
   std::string                         generateVectorSizeCheck( std::string const &                           name,
                                                                CommandData const &                           commandData,
                                                                size_t                                        initialSkipCount,

vulkan/vulkan_handles.hpp

@@ -1565,6 +1565,503 @@ namespace VULKAN_HPP_NAMESPACE
   //=== VK_EXT_pipeline_library_group_handles ===
   struct PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT;
 
+  //===================================
+  //=== HANDLE forward declarations ===
+  //===================================
+
+  //=== VK_VERSION_1_0 ===
+  class Instance;
+  class PhysicalDevice;
+  class Device;
+  class Queue;
+  class DeviceMemory;
+  class Fence;
+  class Semaphore;
+  class Event;
+  class QueryPool;
+  class Buffer;
+  class BufferView;
+  class Image;
+  class ImageView;
+  class ShaderModule;
+  class PipelineCache;
+  class Pipeline;
+  class PipelineLayout;
+  class Sampler;
+  class DescriptorPool;
+  class DescriptorSet;
+  class DescriptorSetLayout;
+  class Framebuffer;
+  class RenderPass;
+  class CommandPool;
+  class CommandBuffer;
+
+  //=== VK_VERSION_1_1 ===
+  class SamplerYcbcrConversion;
+  class DescriptorUpdateTemplate;
+
+  //=== VK_VERSION_1_3 ===
+  class PrivateDataSlot;
+
+  //=== VK_KHR_surface ===
+  class SurfaceKHR;
+
+  //=== VK_KHR_swapchain ===
+  class SwapchainKHR;
+
+  //=== VK_KHR_display ===
+  class DisplayKHR;
+  class DisplayModeKHR;
+
+  //=== VK_EXT_debug_report ===
+  class DebugReportCallbackEXT;
+
+  //=== VK_KHR_video_queue ===
+  class VideoSessionKHR;
+  class VideoSessionParametersKHR;
+
+  //=== VK_NVX_binary_import ===
+  class CuModuleNVX;
+  class CuFunctionNVX;
+
+  //=== VK_EXT_debug_utils ===
+  class DebugUtilsMessengerEXT;
+
+  //=== VK_KHR_acceleration_structure ===
+  class AccelerationStructureKHR;
+
+  //=== VK_EXT_validation_cache ===
+  class ValidationCacheEXT;
+
+  //=== VK_NV_ray_tracing ===
+  class AccelerationStructureNV;
+
+  //=== VK_INTEL_performance_query ===
+  class PerformanceConfigurationINTEL;
+
+  //=== VK_KHR_deferred_host_operations ===
+  class DeferredOperationKHR;
+
+  //=== VK_NV_device_generated_commands ===
+  class IndirectCommandsLayoutNV;
+
+#if defined( VK_USE_PLATFORM_FUCHSIA )
+  //=== VK_FUCHSIA_buffer_collection ===
+  class BufferCollectionFUCHSIA;
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+
+  //=== VK_EXT_opacity_micromap ===
+  class MicromapEXT;
+
+  //=== VK_NV_optical_flow ===
+  class OpticalFlowSessionNV;
+
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+  //======================
+  //=== UNIQUE HANDLEs ===
+  //======================
+
+  //=== VK_VERSION_1_0 ===
+  template <typename Dispatch>
+  class UniqueHandleTraits<Instance, Dispatch>
+  {
+  public:
+    using deleter = ObjectDestroy<NoParent, Dispatch>;
+  };
+
+  using UniqueInstance = UniqueHandle<Instance, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
+
+  template <typename Dispatch>
+  class UniqueHandleTraits<Device, Dispatch>
+  {
+  public:
+    using deleter = ObjectDestroy<NoParent, Dispatch>;
+  };
+
+  using UniqueDevice = UniqueHandle<Device, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
+
+  template <typename Dispatch>
+  class UniqueHandleTraits<DeviceMemory, Dispatch>
+  {
+  public:
+    using deleter = ObjectFree<Device, Dispatch>;
+  };
+
+  using UniqueDeviceMemory = UniqueHandle<DeviceMemory, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
+
+  template <typename Dispatch>
+  class UniqueHandleTraits<Fence, Dispatch>
+  {
+  public:
+    using deleter = ObjectDestroy<Device, Dispatch>;
+  };
+
+  using UniqueFence = UniqueHandle<Fence, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
+
+  template <typename Dispatch>
+  class UniqueHandleTraits<Semaphore, Dispatch>
+  {
+  public:
+    using deleter = ObjectDestroy<Device, Dispatch>;
+  };
+
+  using UniqueSemaphore = UniqueHandle<Semaphore, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
+
+  template <typename Dispatch>
+  class UniqueHandleTraits<Event, Dispatch>
+  {
+  public:
+    using deleter = ObjectDestroy<Device, Dispatch>;
+  };
+
+  using UniqueEvent = UniqueHandle<Event, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
+
+  template <typename Dispatch>
+  class UniqueHandleTraits<QueryPool, Dispatch>
+  {
+  public:
+    using deleter = ObjectDestroy<Device, Dispatch>;
+  };
+
+  using UniqueQueryPool = UniqueHandle<QueryPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
+
+  template <typename Dispatch>
+  class UniqueHandleTraits<Buffer, Dispatch>
+  {
+  public:
+    using deleter = ObjectDestroy<Device, Dispatch>;
+  };
+
+  using UniqueBuffer = UniqueHandle<Buffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
+
+  template <typename Dispatch>
+  class UniqueHandleTraits<BufferView, Dispatch>
+  {
+  public:
+    using deleter = ObjectDestroy<Device, Dispatch>;
+  };
+
+  using UniqueBufferView = UniqueHandle<BufferView, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
+
+  template <typename Dispatch>
+  class UniqueHandleTraits<Image, Dispatch>
+  {
+  public:
+    using deleter = ObjectDestroy<Device, Dispatch>;
+  };
+
+  using UniqueImage = UniqueHandle<Image, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
+
+  template <typename Dispatch>
+  class UniqueHandleTraits<ImageView, Dispatch>
+  {
+  public:
+    using deleter = ObjectDestroy<Device, Dispatch>;
+  };
+
+  using UniqueImageView = UniqueHandle<ImageView, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
+
+  template <typename Dispatch>
+  class UniqueHandleTraits<ShaderModule, Dispatch>
+  {
+  public:
+    using deleter = ObjectDestroy<Device, Dispatch>;
+  };
+
+  using UniqueShaderModule = UniqueHandle<ShaderModule, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
+
+  template <typename Dispatch>
+  class UniqueHandleTraits<PipelineCache, Dispatch>
+  {
+  public:
+    using deleter = ObjectDestroy<Device, Dispatch>;
+  };
+
+  using UniquePipelineCache = UniqueHandle<PipelineCache, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
+
+  template <typename Dispatch>
+  class UniqueHandleTraits<Pipeline, Dispatch>
+  {
+  public:
+    using deleter = ObjectDestroy<Device, Dispatch>;
+  };
+
+  using UniquePipeline = UniqueHandle<Pipeline, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
+
+  template <typename Dispatch>
+  class UniqueHandleTraits<PipelineLayout, Dispatch>
+  {
+  public:
+    using deleter = ObjectDestroy<Device, Dispatch>;
+  };
+
+  using UniquePipelineLayout = UniqueHandle<PipelineLayout, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
+
+  template <typename Dispatch>
+  class UniqueHandleTraits<Sampler, Dispatch>
+  {
+  public:
+    using deleter = ObjectDestroy<Device, Dispatch>;
+  };
+
+  using UniqueSampler = UniqueHandle<Sampler, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
+
+  template <typename Dispatch>
+  class UniqueHandleTraits<DescriptorPool, Dispatch>
+  {
+  public:
+    using deleter = ObjectDestroy<Device, Dispatch>;
+  };
+
+  using UniqueDescriptorPool = UniqueHandle<DescriptorPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
+
+  template <typename Dispatch>
+  class UniqueHandleTraits<DescriptorSet, Dispatch>
+  {
+  public:
+    using deleter = PoolFree<Device, DescriptorPool, Dispatch>;
+  };
+
+  using UniqueDescriptorSet = UniqueHandle<DescriptorSet, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
+
+  template <typename Dispatch>
+  class UniqueHandleTraits<DescriptorSetLayout, Dispatch>
+  {
+  public:
+    using deleter = ObjectDestroy<Device, Dispatch>;
+  };
+
+  using UniqueDescriptorSetLayout = UniqueHandle<DescriptorSetLayout, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
+
+  template <typename Dispatch>
+  class UniqueHandleTraits<Framebuffer, Dispatch>
+  {
+  public:
+    using deleter = ObjectDestroy<Device, Dispatch>;
+  };
+
+  using UniqueFramebuffer = UniqueHandle<Framebuffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
+
+  template <typename Dispatch>
+  class UniqueHandleTraits<RenderPass, Dispatch>
+  {
+  public:
+    using deleter = ObjectDestroy<Device, Dispatch>;
+  };
+
+  using UniqueRenderPass = UniqueHandle<RenderPass, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
+
+  template <typename Dispatch>
+  class UniqueHandleTraits<CommandPool, Dispatch>
+  {
+  public:
+    using deleter = ObjectDestroy<Device, Dispatch>;
+  };
+
+  using UniqueCommandPool = UniqueHandle<CommandPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
+
+  template <typename Dispatch>
+  class UniqueHandleTraits<CommandBuffer, Dispatch>
+  {
+  public:
+    using deleter = PoolFree<Device, CommandPool, Dispatch>;
+  };
+
+  using UniqueCommandBuffer = UniqueHandle<CommandBuffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
+
+  //=== VK_VERSION_1_1 ===
+  template <typename Dispatch>
+  class UniqueHandleTraits<SamplerYcbcrConversion, Dispatch>
+  {
+  public:
+    using deleter = ObjectDestroy<Device, Dispatch>;
+  };
+
+  using UniqueSamplerYcbcrConversion    = UniqueHandle<SamplerYcbcrConversion, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
+  using UniqueSamplerYcbcrConversionKHR = UniqueHandle<SamplerYcbcrConversion, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
+
+  template <typename Dispatch>
+  class UniqueHandleTraits<DescriptorUpdateTemplate, Dispatch>
+  {
+  public:
+    using deleter = ObjectDestroy<Device, Dispatch>;
+  };
+
+  using UniqueDescriptorUpdateTemplate    = UniqueHandle<DescriptorUpdateTemplate, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
+  using UniqueDescriptorUpdateTemplateKHR = UniqueHandle<DescriptorUpdateTemplate, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
+
+  //=== VK_VERSION_1_3 ===
+  template <typename Dispatch>
+  class UniqueHandleTraits<PrivateDataSlot, Dispatch>
+  {
+  public:
+    using deleter = ObjectDestroy<Device, Dispatch>;
+  };
+
+  using UniquePrivateDataSlot    = UniqueHandle<PrivateDataSlot, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
+  using UniquePrivateDataSlotEXT = UniqueHandle<PrivateDataSlot, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
+
+  //=== VK_KHR_surface ===
+  template <typename Dispatch>
+  class UniqueHandleTraits<SurfaceKHR, Dispatch>
+  {
+  public:
+    using deleter = ObjectDestroy<Instance, Dispatch>;
+  };
+
+  using UniqueSurfaceKHR = UniqueHandle<SurfaceKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
+
+  //=== VK_KHR_swapchain ===
+  template <typename Dispatch>
+  class UniqueHandleTraits<SwapchainKHR, Dispatch>
+  {
+  public:
+    using deleter = ObjectDestroy<Device, Dispatch>;
+  };
+
+  using UniqueSwapchainKHR = UniqueHandle<SwapchainKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
+
+  //=== VK_EXT_debug_report ===
+  template <typename Dispatch>
+  class UniqueHandleTraits<DebugReportCallbackEXT, Dispatch>
+  {
+  public:
+    using deleter = ObjectDestroy<Instance, Dispatch>;
+  };
+
+  using UniqueDebugReportCallbackEXT = UniqueHandle<DebugReportCallbackEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
+
+  //=== VK_KHR_video_queue ===
+  template <typename Dispatch>
+  class UniqueHandleTraits<VideoSessionKHR, Dispatch>
+  {
+  public:
+    using deleter = ObjectDestroy<Device, Dispatch>;
+  };
+
+  using UniqueVideoSessionKHR = UniqueHandle<VideoSessionKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
+
+  template <typename Dispatch>
+  class UniqueHandleTraits<VideoSessionParametersKHR, Dispatch>
+  {
+  public:
+    using deleter = ObjectDestroy<Device, Dispatch>;
+  };
+
+  using UniqueVideoSessionParametersKHR = UniqueHandle<VideoSessionParametersKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
+
+  //=== VK_NVX_binary_import ===
+  template <typename Dispatch>
+  class UniqueHandleTraits<CuModuleNVX, Dispatch>
+  {
+  public:
+    using deleter = ObjectDestroy<Device, Dispatch>;
+  };
+
+  using UniqueCuModuleNVX = UniqueHandle<CuModuleNVX, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
+
+  template <typename Dispatch>
+  class UniqueHandleTraits<CuFunctionNVX, Dispatch>
+  {
+  public:
+    using deleter = ObjectDestroy<Device, Dispatch>;
+  };
+
+  using UniqueCuFunctionNVX = UniqueHandle<CuFunctionNVX, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
+
+  //=== VK_EXT_debug_utils ===
+  template <typename Dispatch>
+  class UniqueHandleTraits<DebugUtilsMessengerEXT, Dispatch>
+  {
+  public:
+    using deleter = ObjectDestroy<Instance, Dispatch>;
+  };
+
+  using UniqueDebugUtilsMessengerEXT = UniqueHandle<DebugUtilsMessengerEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
+
+  //=== VK_KHR_acceleration_structure ===
+  template <typename Dispatch>
+  class UniqueHandleTraits<AccelerationStructureKHR, Dispatch>
+  {
+  public:
+    using deleter = ObjectDestroy<Device, Dispatch>;
+  };
+
+  using UniqueAccelerationStructureKHR = UniqueHandle<AccelerationStructureKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
+
+  //=== VK_EXT_validation_cache ===
+  template <typename Dispatch>
+  class UniqueHandleTraits<ValidationCacheEXT, Dispatch>
+  {
+  public:
+    using deleter = ObjectDestroy<Device, Dispatch>;
+  };
+
+  using UniqueValidationCacheEXT = UniqueHandle<ValidationCacheEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
+
+  //=== VK_NV_ray_tracing ===
+  template <typename Dispatch>
+  class UniqueHandleTraits<AccelerationStructureNV, Dispatch>
+  {
+  public:
+    using deleter = ObjectDestroy<Device, Dispatch>;
+  };
+
+  using UniqueAccelerationStructureNV = UniqueHandle<AccelerationStructureNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
+
+  //=== VK_KHR_deferred_host_operations ===
+  template <typename Dispatch>
+  class UniqueHandleTraits<DeferredOperationKHR, Dispatch>
+  {
+  public:
+    using deleter = ObjectDestroy<Device, Dispatch>;
+  };
+
+  using UniqueDeferredOperationKHR = UniqueHandle<DeferredOperationKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
+
+  //=== VK_NV_device_generated_commands ===
+  template <typename Dispatch>
+  class UniqueHandleTraits<IndirectCommandsLayoutNV, Dispatch>
+  {
+  public:
+    using deleter = ObjectDestroy<Device, Dispatch>;
+  };
+
+  using UniqueIndirectCommandsLayoutNV = UniqueHandle<IndirectCommandsLayoutNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
+
+#  if defined( VK_USE_PLATFORM_FUCHSIA )
+  //=== VK_FUCHSIA_buffer_collection ===
+  template <typename Dispatch>
+  class UniqueHandleTraits<BufferCollectionFUCHSIA, Dispatch>
+  {
+  public:
+    using deleter = ObjectDestroy<Device, Dispatch>;
+  };
+
+  using UniqueBufferCollectionFUCHSIA = UniqueHandle<BufferCollectionFUCHSIA, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
+#  endif /*VK_USE_PLATFORM_FUCHSIA*/
+
+  //=== VK_EXT_opacity_micromap ===
+  template <typename Dispatch>
+  class UniqueHandleTraits<MicromapEXT, Dispatch>
+  {
+  public:
+    using deleter = ObjectDestroy<Device, Dispatch>;
+  };
+
+  using UniqueMicromapEXT = UniqueHandle<MicromapEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
+
+  //=== VK_NV_optical_flow ===
+  template <typename Dispatch>
+  class UniqueHandleTraits<OpticalFlowSessionNV, Dispatch>
+  {
+  public:
+    using deleter = ObjectDestroy<Device, Dispatch>;
+  };
+
+  using UniqueOpticalFlowSessionNV = UniqueHandle<OpticalFlowSessionNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+
   //===============
   //=== HANDLEs ===
   //===============
@@ -7561,346 +8058,6 @@ namespace VULKAN_HPP_NAMESPACE
     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
   };
 
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  class Device;
-
-  template <typename Dispatch>
-  class UniqueHandleTraits<AccelerationStructureKHR, Dispatch>
-  {
-  public:
-    using deleter = ObjectDestroy<Device, Dispatch>;
-  };
-
-  using UniqueAccelerationStructureKHR = UniqueHandle<AccelerationStructureKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
-
-  template <typename Dispatch>
-  class UniqueHandleTraits<AccelerationStructureNV, Dispatch>
-  {
-  public:
-    using deleter = ObjectDestroy<Device, Dispatch>;
-  };
-
-  using UniqueAccelerationStructureNV = UniqueHandle<AccelerationStructureNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
-
-  template <typename Dispatch>
-  class UniqueHandleTraits<Buffer, Dispatch>
-  {
-  public:
-    using deleter = ObjectDestroy<Device, Dispatch>;
-  };
-
-  using UniqueBuffer = UniqueHandle<Buffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
-#  if defined( VK_USE_PLATFORM_FUCHSIA )
-  template <typename Dispatch>
-  class UniqueHandleTraits<BufferCollectionFUCHSIA, Dispatch>
-  {
-  public:
-    using deleter = ObjectDestroy<Device, Dispatch>;
-  };
-
-  using UniqueBufferCollectionFUCHSIA = UniqueHandle<BufferCollectionFUCHSIA, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
-#  endif /*VK_USE_PLATFORM_FUCHSIA*/
-  template <typename Dispatch>
-  class UniqueHandleTraits<BufferView, Dispatch>
-  {
-  public:
-    using deleter = ObjectDestroy<Device, Dispatch>;
-  };
-
-  using UniqueBufferView = UniqueHandle<BufferView, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
-
-  template <typename Dispatch>
-  class UniqueHandleTraits<CommandBuffer, Dispatch>
-  {
-  public:
-    using deleter = PoolFree<Device, CommandPool, Dispatch>;
-  };
-
-  using UniqueCommandBuffer = UniqueHandle<CommandBuffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
-
-  template <typename Dispatch>
-  class UniqueHandleTraits<CommandPool, Dispatch>
-  {
-  public:
-    using deleter = ObjectDestroy<Device, Dispatch>;
-  };
-
-  using UniqueCommandPool = UniqueHandle<CommandPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
-
-  template <typename Dispatch>
-  class UniqueHandleTraits<CuFunctionNVX, Dispatch>
-  {
-  public:
-    using deleter = ObjectDestroy<Device, Dispatch>;
-  };
-
-  using UniqueCuFunctionNVX = UniqueHandle<CuFunctionNVX, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
-
-  template <typename Dispatch>
-  class UniqueHandleTraits<CuModuleNVX, Dispatch>
-  {
-  public:
-    using deleter = ObjectDestroy<Device, Dispatch>;
-  };
-
-  using UniqueCuModuleNVX = UniqueHandle<CuModuleNVX, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
-
-  template <typename Dispatch>
-  class UniqueHandleTraits<DeferredOperationKHR, Dispatch>
-  {
-  public:
-    using deleter = ObjectDestroy<Device, Dispatch>;
-  };
-
-  using UniqueDeferredOperationKHR = UniqueHandle<DeferredOperationKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
-
-  template <typename Dispatch>
-  class UniqueHandleTraits<DescriptorPool, Dispatch>
-  {
-  public:
-    using deleter = ObjectDestroy<Device, Dispatch>;
-  };
-
-  using UniqueDescriptorPool = UniqueHandle<DescriptorPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
-
-  template <typename Dispatch>
-  class UniqueHandleTraits<DescriptorSet, Dispatch>
-  {
-  public:
-    using deleter = PoolFree<Device, DescriptorPool, Dispatch>;
-  };
-
-  using UniqueDescriptorSet = UniqueHandle<DescriptorSet, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
-
-  template <typename Dispatch>
-  class UniqueHandleTraits<DescriptorSetLayout, Dispatch>
-  {
-  public:
-    using deleter = ObjectDestroy<Device, Dispatch>;
-  };
-
-  using UniqueDescriptorSetLayout = UniqueHandle<DescriptorSetLayout, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
-
-  template <typename Dispatch>
-  class UniqueHandleTraits<DescriptorUpdateTemplate, Dispatch>
-  {
-  public:
-    using deleter = ObjectDestroy<Device, Dispatch>;
-  };
-
-  using UniqueDescriptorUpdateTemplate    = UniqueHandle<DescriptorUpdateTemplate, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
-  using UniqueDescriptorUpdateTemplateKHR = UniqueHandle<DescriptorUpdateTemplate, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
-
-  template <typename Dispatch>
-  class UniqueHandleTraits<DeviceMemory, Dispatch>
-  {
-  public:
-    using deleter = ObjectFree<Device, Dispatch>;
-  };
-
-  using UniqueDeviceMemory = UniqueHandle<DeviceMemory, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
-
-  template <typename Dispatch>
-  class UniqueHandleTraits<Event, Dispatch>
-  {
-  public:
-    using deleter = ObjectDestroy<Device, Dispatch>;
-  };
-
-  using UniqueEvent = UniqueHandle<Event, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
-
-  template <typename Dispatch>
-  class UniqueHandleTraits<Fence, Dispatch>
-  {
-  public:
-    using deleter = ObjectDestroy<Device, Dispatch>;
-  };
-
-  using UniqueFence = UniqueHandle<Fence, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
-
-  template <typename Dispatch>
-  class UniqueHandleTraits<Framebuffer, Dispatch>
-  {
-  public:
-    using deleter = ObjectDestroy<Device, Dispatch>;
-  };
-
-  using UniqueFramebuffer = UniqueHandle<Framebuffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
-
-  template <typename Dispatch>
-  class UniqueHandleTraits<Image, Dispatch>
-  {
-  public:
-    using deleter = ObjectDestroy<Device, Dispatch>;
-  };
-
-  using UniqueImage = UniqueHandle<Image, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
-
-  template <typename Dispatch>
-  class UniqueHandleTraits<ImageView, Dispatch>
-  {
-  public:
-    using deleter = ObjectDestroy<Device, Dispatch>;
-  };
-
-  using UniqueImageView = UniqueHandle<ImageView, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
-
-  template <typename Dispatch>
-  class UniqueHandleTraits<IndirectCommandsLayoutNV, Dispatch>
-  {
-  public:
-    using deleter = ObjectDestroy<Device, Dispatch>;
-  };
-
-  using UniqueIndirectCommandsLayoutNV = UniqueHandle<IndirectCommandsLayoutNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
-
-  template <typename Dispatch>
-  class UniqueHandleTraits<MicromapEXT, Dispatch>
-  {
-  public:
-    using deleter = ObjectDestroy<Device, Dispatch>;
-  };
-
-  using UniqueMicromapEXT = UniqueHandle<MicromapEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
-
-  template <typename Dispatch>
-  class UniqueHandleTraits<OpticalFlowSessionNV, Dispatch>
-  {
-  public:
-    using deleter = ObjectDestroy<Device, Dispatch>;
-  };
-
-  using UniqueOpticalFlowSessionNV = UniqueHandle<OpticalFlowSessionNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
-
-  template <typename Dispatch>
-  class UniqueHandleTraits<Pipeline, Dispatch>
-  {
-  public:
-    using deleter = ObjectDestroy<Device, Dispatch>;
-  };
-
-  using UniquePipeline = UniqueHandle<Pipeline, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
-
-  template <typename Dispatch>
-  class UniqueHandleTraits<PipelineCache, Dispatch>
-  {
-  public:
-    using deleter = ObjectDestroy<Device, Dispatch>;
-  };
-
-  using UniquePipelineCache = UniqueHandle<PipelineCache, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
-
-  template <typename Dispatch>
-  class UniqueHandleTraits<PipelineLayout, Dispatch>
-  {
-  public:
-    using deleter = ObjectDestroy<Device, Dispatch>;
-  };
-
-  using UniquePipelineLayout = UniqueHandle<PipelineLayout, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
-
-  template <typename Dispatch>
-  class UniqueHandleTraits<PrivateDataSlot, Dispatch>
-  {
-  public:
-    using deleter = ObjectDestroy<Device, Dispatch>;
-  };
-
-  using UniquePrivateDataSlot    = UniqueHandle<PrivateDataSlot, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
-  using UniquePrivateDataSlotEXT = UniqueHandle<PrivateDataSlot, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
-
-  template <typename Dispatch>
-  class UniqueHandleTraits<QueryPool, Dispatch>
-  {
-  public:
-    using deleter = ObjectDestroy<Device, Dispatch>;
-  };
-
-  using UniqueQueryPool = UniqueHandle<QueryPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
-
-  template <typename Dispatch>
-  class UniqueHandleTraits<RenderPass, Dispatch>
-  {
-  public:
-    using deleter = ObjectDestroy<Device, Dispatch>;
-  };
-
-  using UniqueRenderPass = UniqueHandle<RenderPass, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
-
-  template <typename Dispatch>
-  class UniqueHandleTraits<Sampler, Dispatch>
-  {
-  public:
-    using deleter = ObjectDestroy<Device, Dispatch>;
-  };
-
-  using UniqueSampler = UniqueHandle<Sampler, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
-
-  template <typename Dispatch>
-  class UniqueHandleTraits<SamplerYcbcrConversion, Dispatch>
-  {
-  public:
-    using deleter = ObjectDestroy<Device, Dispatch>;
-  };
-
-  using UniqueSamplerYcbcrConversion    = UniqueHandle<SamplerYcbcrConversion, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
-  using UniqueSamplerYcbcrConversionKHR = UniqueHandle<SamplerYcbcrConversion, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
-
-  template <typename Dispatch>
-  class UniqueHandleTraits<Semaphore, Dispatch>
-  {
-  public:
-    using deleter = ObjectDestroy<Device, Dispatch>;
-  };
-
-  using UniqueSemaphore = UniqueHandle<Semaphore, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
-
-  template <typename Dispatch>
-  class UniqueHandleTraits<ShaderModule, Dispatch>
-  {
-  public:
-    using deleter = ObjectDestroy<Device, Dispatch>;
-  };
-
-  using UniqueShaderModule = UniqueHandle<ShaderModule, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
-
-  template <typename Dispatch>
-  class UniqueHandleTraits<SwapchainKHR, Dispatch>
-  {
-  public:
-    using deleter = ObjectDestroy<Device, Dispatch>;
-  };
-
-  using UniqueSwapchainKHR = UniqueHandle<SwapchainKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
-
-  template <typename Dispatch>
-  class UniqueHandleTraits<ValidationCacheEXT, Dispatch>
-  {
-  public:
-    using deleter = ObjectDestroy<Device, Dispatch>;
-  };
-
-  using UniqueValidationCacheEXT = UniqueHandle<ValidationCacheEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
-
-  template <typename Dispatch>
-  class UniqueHandleTraits<VideoSessionKHR, Dispatch>
-  {
-  public:
-    using deleter = ObjectDestroy<Device, Dispatch>;
-  };
-
-  using UniqueVideoSessionKHR = UniqueHandle<VideoSessionKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
-
-  template <typename Dispatch>
-  class UniqueHandleTraits<VideoSessionParametersKHR, Dispatch>
-  {
-  public:
-    using deleter = ObjectDestroy<Device, Dispatch>;
-  };
-
-  using UniqueVideoSessionParametersKHR = UniqueHandle<VideoSessionParametersKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-
   class Device
   {
   public:
@@ -12574,17 +12731,6 @@ namespace VULKAN_HPP_NAMESPACE
     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
   };
 
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Dispatch>
-  class UniqueHandleTraits<Device, Dispatch>
-  {
-  public:
-    using deleter = ObjectDestroy<NoParent, Dispatch>;
-  };
-
-  using UniqueDevice = UniqueHandle<Device, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-
   class PhysicalDevice
   {
   public:
@@ -13941,37 +14087,6 @@ namespace VULKAN_HPP_NAMESPACE
     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
   };
 
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  class Instance;
-
-  template <typename Dispatch>
-  class UniqueHandleTraits<DebugReportCallbackEXT, Dispatch>
-  {
-  public:
-    using deleter = ObjectDestroy<Instance, Dispatch>;
-  };
-
-  using UniqueDebugReportCallbackEXT = UniqueHandle<DebugReportCallbackEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
-
-  template <typename Dispatch>
-  class UniqueHandleTraits<DebugUtilsMessengerEXT, Dispatch>
-  {
-  public:
-    using deleter = ObjectDestroy<Instance, Dispatch>;
-  };
-
-  using UniqueDebugUtilsMessengerEXT = UniqueHandle<DebugUtilsMessengerEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
-
-  template <typename Dispatch>
-  class UniqueHandleTraits<SurfaceKHR, Dispatch>
-  {
-  public:
-    using deleter = ObjectDestroy<Instance, Dispatch>;
-  };
-
-  using UniqueSurfaceKHR = UniqueHandle<SurfaceKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-
   class Instance
   {
   public:
@@ -14639,17 +14754,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   //=== VK_VERSION_1_0 ===
 
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Dispatch>
-  class UniqueHandleTraits<Instance, Dispatch>
-  {
-  public:
-    using deleter = ObjectDestroy<NoParent, Dispatch>;
-  };
-
-  using UniqueInstance = UniqueHandle<Instance, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-
   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
   VULKAN_HPP_NODISCARD Result createInstance( const VULKAN_HPP_NAMESPACE::InstanceCreateInfo *  pCreateInfo,
                                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,