diff --git a/VulkanHppGenerator.cpp b/VulkanHppGenerator.cpp
index 665db34..0db990c 100644
--- a/VulkanHppGenerator.cpp
+++ b/VulkanHppGenerator.cpp
@@ -3455,6 +3455,8 @@ void VulkanHppGenerator::writeHandle(std::ostream & os, std::pair<std::string, H
   public:
     using CType = Vk${className};
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::e${className};
+
   public:
     VULKAN_HPP_CONSTEXPR ${className}()
       : m_${memberName}(VK_NULL_HANDLE)
@@ -3516,6 +3518,12 @@ ${commands}
     Vk${className} m_${memberName};
   };
   static_assert( sizeof( ${className} ) == sizeof( Vk${className} ), "handle and wrapper have different size!" );
+
+  template <>
+  struct cpp_type<ObjectType::e${className}>
+  {
+    using type = ${className};
+  };
 )";
 
       os << replaceWithMap(templateString, {
@@ -4810,8 +4818,10 @@ int main( int argc, char **argv )
 
 #if defined(_MSC_VER) && (_MSC_VER <= 1800)
 # define VULKAN_HPP_CONSTEXPR
+# define VULKAN_HPP_CONST_OR_CONSTEXPR  const
 #else
 # define VULKAN_HPP_CONSTEXPR constexpr
+# define VULKAN_HPP_CONST_OR_CONSTEXPR  constexpr
 #endif
 
 #if !defined(VULKAN_HPP_NAMESPACE)
@@ -5052,6 +5062,13 @@ namespace std
 #endif
 )";
 
+  static const std::string typeTraits = R"(
+  template<ObjectType value>
+  struct cpp_type
+  {
+  };
+)";
+
   try {
     tinyxml2::XMLDocument doc;
 
@@ -5150,6 +5167,7 @@ namespace std
       << std::endl;
     generator.writeBaseTypes(ofs);
     generator.writeEnums(ofs);
+    ofs << typeTraits;
     generator.writeBitmasks(ofs);
     ofs << "} // namespace VULKAN_HPP_NAMESPACE" << std::endl
       << is_error_code_enum
diff --git a/vulkan/vulkan.hpp b/vulkan/vulkan.hpp
index 2f2714f..ba86939 100644
--- a/vulkan/vulkan.hpp
+++ b/vulkan/vulkan.hpp
@@ -123,8 +123,10 @@ static_assert( VK_HEADER_VERSION ==  108 , "Wrong VK_HEADER_VERSION!" );
 
 #if defined(_MSC_VER) && (_MSC_VER <= 1800)
 # define VULKAN_HPP_CONSTEXPR
+# define VULKAN_HPP_CONST_OR_CONSTEXPR  const
 #else
 # define VULKAN_HPP_CONSTEXPR constexpr
+# define VULKAN_HPP_CONST_OR_CONSTEXPR  constexpr
 #endif
 
 #if !defined(VULKAN_HPP_NAMESPACE)
@@ -5780,6 +5782,11 @@ namespace VULKAN_HPP_NAMESPACE
     }
   }
 
+  template<ObjectType value>
+  struct cpp_type
+  {
+  };
+
   enum class AccessFlagBits
   {
     eIndirectCommandRead = VK_ACCESS_INDIRECT_COMMAND_READ_BIT,
@@ -11348,6 +11355,8 @@ namespace VULKAN_HPP_NAMESPACE
   public:
     using CType = VkSurfaceKHR;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSurfaceKHR;
+
   public:
     VULKAN_HPP_CONSTEXPR SurfaceKHR()
       : m_surfaceKHR(VK_NULL_HANDLE)
@@ -11410,11 +11419,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( SurfaceKHR ) == sizeof( VkSurfaceKHR ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eSurfaceKHR>
+  {
+    using type = SurfaceKHR;
+  };
+
   class DebugReportCallbackEXT
   {
   public:
     using CType = VkDebugReportCallbackEXT;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDebugReportCallbackEXT;
+
   public:
     VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT()
       : m_debugReportCallbackEXT(VK_NULL_HANDLE)
@@ -11477,11 +11494,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( DebugReportCallbackEXT ) == sizeof( VkDebugReportCallbackEXT ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eDebugReportCallbackEXT>
+  {
+    using type = DebugReportCallbackEXT;
+  };
+
   class DebugUtilsMessengerEXT
   {
   public:
     using CType = VkDebugUtilsMessengerEXT;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDebugUtilsMessengerEXT;
+
   public:
     VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT()
       : m_debugUtilsMessengerEXT(VK_NULL_HANDLE)
@@ -11544,11 +11569,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( DebugUtilsMessengerEXT ) == sizeof( VkDebugUtilsMessengerEXT ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eDebugUtilsMessengerEXT>
+  {
+    using type = DebugUtilsMessengerEXT;
+  };
+
   class DisplayKHR
   {
   public:
     using CType = VkDisplayKHR;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDisplayKHR;
+
   public:
     VULKAN_HPP_CONSTEXPR DisplayKHR()
       : m_displayKHR(VK_NULL_HANDLE)
@@ -11611,11 +11644,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( DisplayKHR ) == sizeof( VkDisplayKHR ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eDisplayKHR>
+  {
+    using type = DisplayKHR;
+  };
+
   class SwapchainKHR
   {
   public:
     using CType = VkSwapchainKHR;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSwapchainKHR;
+
   public:
     VULKAN_HPP_CONSTEXPR SwapchainKHR()
       : m_swapchainKHR(VK_NULL_HANDLE)
@@ -11678,11 +11719,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( SwapchainKHR ) == sizeof( VkSwapchainKHR ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eSwapchainKHR>
+  {
+    using type = SwapchainKHR;
+  };
+
   class Semaphore
   {
   public:
     using CType = VkSemaphore;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSemaphore;
+
   public:
     VULKAN_HPP_CONSTEXPR Semaphore()
       : m_semaphore(VK_NULL_HANDLE)
@@ -11745,11 +11794,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( Semaphore ) == sizeof( VkSemaphore ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eSemaphore>
+  {
+    using type = Semaphore;
+  };
+
   class Fence
   {
   public:
     using CType = VkFence;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eFence;
+
   public:
     VULKAN_HPP_CONSTEXPR Fence()
       : m_fence(VK_NULL_HANDLE)
@@ -11812,11 +11869,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( Fence ) == sizeof( VkFence ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eFence>
+  {
+    using type = Fence;
+  };
+
   class QueryPool
   {
   public:
     using CType = VkQueryPool;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eQueryPool;
+
   public:
     VULKAN_HPP_CONSTEXPR QueryPool()
       : m_queryPool(VK_NULL_HANDLE)
@@ -11879,11 +11944,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( QueryPool ) == sizeof( VkQueryPool ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eQueryPool>
+  {
+    using type = QueryPool;
+  };
+
   class Buffer
   {
   public:
     using CType = VkBuffer;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eBuffer;
+
   public:
     VULKAN_HPP_CONSTEXPR Buffer()
       : m_buffer(VK_NULL_HANDLE)
@@ -11946,11 +12019,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( Buffer ) == sizeof( VkBuffer ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eBuffer>
+  {
+    using type = Buffer;
+  };
+
   class PipelineLayout
   {
   public:
     using CType = VkPipelineLayout;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePipelineLayout;
+
   public:
     VULKAN_HPP_CONSTEXPR PipelineLayout()
       : m_pipelineLayout(VK_NULL_HANDLE)
@@ -12013,11 +12094,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( PipelineLayout ) == sizeof( VkPipelineLayout ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::ePipelineLayout>
+  {
+    using type = PipelineLayout;
+  };
+
   class DescriptorSet
   {
   public:
     using CType = VkDescriptorSet;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDescriptorSet;
+
   public:
     VULKAN_HPP_CONSTEXPR DescriptorSet()
       : m_descriptorSet(VK_NULL_HANDLE)
@@ -12080,11 +12169,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( DescriptorSet ) == sizeof( VkDescriptorSet ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eDescriptorSet>
+  {
+    using type = DescriptorSet;
+  };
+
   class Pipeline
   {
   public:
     using CType = VkPipeline;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePipeline;
+
   public:
     VULKAN_HPP_CONSTEXPR Pipeline()
       : m_pipeline(VK_NULL_HANDLE)
@@ -12147,11 +12244,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( Pipeline ) == sizeof( VkPipeline ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::ePipeline>
+  {
+    using type = Pipeline;
+  };
+
   class ImageView
   {
   public:
     using CType = VkImageView;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eImageView;
+
   public:
     VULKAN_HPP_CONSTEXPR ImageView()
       : m_imageView(VK_NULL_HANDLE)
@@ -12214,11 +12319,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( ImageView ) == sizeof( VkImageView ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eImageView>
+  {
+    using type = ImageView;
+  };
+
   class Image
   {
   public:
     using CType = VkImage;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eImage;
+
   public:
     VULKAN_HPP_CONSTEXPR Image()
       : m_image(VK_NULL_HANDLE)
@@ -12281,11 +12394,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( Image ) == sizeof( VkImage ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eImage>
+  {
+    using type = Image;
+  };
+
   class AccelerationStructureNV
   {
   public:
     using CType = VkAccelerationStructureNV;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eAccelerationStructureNV;
+
   public:
     VULKAN_HPP_CONSTEXPR AccelerationStructureNV()
       : m_accelerationStructureNV(VK_NULL_HANDLE)
@@ -12348,11 +12469,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( AccelerationStructureNV ) == sizeof( VkAccelerationStructureNV ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eAccelerationStructureNV>
+  {
+    using type = AccelerationStructureNV;
+  };
+
   class DescriptorUpdateTemplate
   {
   public:
     using CType = VkDescriptorUpdateTemplate;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDescriptorUpdateTemplate;
+
   public:
     VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate()
       : m_descriptorUpdateTemplate(VK_NULL_HANDLE)
@@ -12414,6 +12543,12 @@ namespace VULKAN_HPP_NAMESPACE
     VkDescriptorUpdateTemplate m_descriptorUpdateTemplate;
   };
   static_assert( sizeof( DescriptorUpdateTemplate ) == sizeof( VkDescriptorUpdateTemplate ), "handle and wrapper have different size!" );
+
+  template <>
+  struct cpp_type<ObjectType::eDescriptorUpdateTemplate>
+  {
+    using type = DescriptorUpdateTemplate;
+  };
   using DescriptorUpdateTemplateKHR = DescriptorUpdateTemplate;
 
   class Event
@@ -12421,6 +12556,8 @@ namespace VULKAN_HPP_NAMESPACE
   public:
     using CType = VkEvent;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eEvent;
+
   public:
     VULKAN_HPP_CONSTEXPR Event()
       : m_event(VK_NULL_HANDLE)
@@ -12483,11 +12620,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( Event ) == sizeof( VkEvent ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eEvent>
+  {
+    using type = Event;
+  };
+
   class CommandBuffer
   {
   public:
     using CType = VkCommandBuffer;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eCommandBuffer;
+
   public:
     VULKAN_HPP_CONSTEXPR CommandBuffer()
       : m_commandBuffer(VK_NULL_HANDLE)
@@ -13004,11 +13149,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( CommandBuffer ) == sizeof( VkCommandBuffer ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eCommandBuffer>
+  {
+    using type = CommandBuffer;
+  };
+
   class DeviceMemory
   {
   public:
     using CType = VkDeviceMemory;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDeviceMemory;
+
   public:
     VULKAN_HPP_CONSTEXPR DeviceMemory()
       : m_deviceMemory(VK_NULL_HANDLE)
@@ -13071,11 +13224,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( DeviceMemory ) == sizeof( VkDeviceMemory ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eDeviceMemory>
+  {
+    using type = DeviceMemory;
+  };
+
   class BufferView
   {
   public:
     using CType = VkBufferView;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eBufferView;
+
   public:
     VULKAN_HPP_CONSTEXPR BufferView()
       : m_bufferView(VK_NULL_HANDLE)
@@ -13138,11 +13299,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( BufferView ) == sizeof( VkBufferView ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eBufferView>
+  {
+    using type = BufferView;
+  };
+
   class CommandPool
   {
   public:
     using CType = VkCommandPool;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eCommandPool;
+
   public:
     VULKAN_HPP_CONSTEXPR CommandPool()
       : m_commandPool(VK_NULL_HANDLE)
@@ -13205,11 +13374,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( CommandPool ) == sizeof( VkCommandPool ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eCommandPool>
+  {
+    using type = CommandPool;
+  };
+
   class PipelineCache
   {
   public:
     using CType = VkPipelineCache;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePipelineCache;
+
   public:
     VULKAN_HPP_CONSTEXPR PipelineCache()
       : m_pipelineCache(VK_NULL_HANDLE)
@@ -13272,11 +13449,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( PipelineCache ) == sizeof( VkPipelineCache ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::ePipelineCache>
+  {
+    using type = PipelineCache;
+  };
+
   class DescriptorPool
   {
   public:
     using CType = VkDescriptorPool;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDescriptorPool;
+
   public:
     VULKAN_HPP_CONSTEXPR DescriptorPool()
       : m_descriptorPool(VK_NULL_HANDLE)
@@ -13339,11 +13524,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( DescriptorPool ) == sizeof( VkDescriptorPool ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eDescriptorPool>
+  {
+    using type = DescriptorPool;
+  };
+
   class DescriptorSetLayout
   {
   public:
     using CType = VkDescriptorSetLayout;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDescriptorSetLayout;
+
   public:
     VULKAN_HPP_CONSTEXPR DescriptorSetLayout()
       : m_descriptorSetLayout(VK_NULL_HANDLE)
@@ -13406,11 +13599,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( DescriptorSetLayout ) == sizeof( VkDescriptorSetLayout ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eDescriptorSetLayout>
+  {
+    using type = DescriptorSetLayout;
+  };
+
   class Framebuffer
   {
   public:
     using CType = VkFramebuffer;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eFramebuffer;
+
   public:
     VULKAN_HPP_CONSTEXPR Framebuffer()
       : m_framebuffer(VK_NULL_HANDLE)
@@ -13473,11 +13674,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( Framebuffer ) == sizeof( VkFramebuffer ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eFramebuffer>
+  {
+    using type = Framebuffer;
+  };
+
   class IndirectCommandsLayoutNVX
   {
   public:
     using CType = VkIndirectCommandsLayoutNVX;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eIndirectCommandsLayoutNVX;
+
   public:
     VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNVX()
       : m_indirectCommandsLayoutNVX(VK_NULL_HANDLE)
@@ -13540,11 +13749,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( IndirectCommandsLayoutNVX ) == sizeof( VkIndirectCommandsLayoutNVX ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eIndirectCommandsLayoutNVX>
+  {
+    using type = IndirectCommandsLayoutNVX;
+  };
+
   class ObjectTableNVX
   {
   public:
     using CType = VkObjectTableNVX;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eObjectTableNVX;
+
   public:
     VULKAN_HPP_CONSTEXPR ObjectTableNVX()
       : m_objectTableNVX(VK_NULL_HANDLE)
@@ -13607,11 +13824,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( ObjectTableNVX ) == sizeof( VkObjectTableNVX ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eObjectTableNVX>
+  {
+    using type = ObjectTableNVX;
+  };
+
   class RenderPass
   {
   public:
     using CType = VkRenderPass;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eRenderPass;
+
   public:
     VULKAN_HPP_CONSTEXPR RenderPass()
       : m_renderPass(VK_NULL_HANDLE)
@@ -13674,11 +13899,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( RenderPass ) == sizeof( VkRenderPass ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eRenderPass>
+  {
+    using type = RenderPass;
+  };
+
   class Sampler
   {
   public:
     using CType = VkSampler;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSampler;
+
   public:
     VULKAN_HPP_CONSTEXPR Sampler()
       : m_sampler(VK_NULL_HANDLE)
@@ -13741,11 +13974,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( Sampler ) == sizeof( VkSampler ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eSampler>
+  {
+    using type = Sampler;
+  };
+
   class SamplerYcbcrConversion
   {
   public:
     using CType = VkSamplerYcbcrConversion;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSamplerYcbcrConversion;
+
   public:
     VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion()
       : m_samplerYcbcrConversion(VK_NULL_HANDLE)
@@ -13807,6 +14048,12 @@ namespace VULKAN_HPP_NAMESPACE
     VkSamplerYcbcrConversion m_samplerYcbcrConversion;
   };
   static_assert( sizeof( SamplerYcbcrConversion ) == sizeof( VkSamplerYcbcrConversion ), "handle and wrapper have different size!" );
+
+  template <>
+  struct cpp_type<ObjectType::eSamplerYcbcrConversion>
+  {
+    using type = SamplerYcbcrConversion;
+  };
   using SamplerYcbcrConversionKHR = SamplerYcbcrConversion;
 
   class ShaderModule
@@ -13814,6 +14061,8 @@ namespace VULKAN_HPP_NAMESPACE
   public:
     using CType = VkShaderModule;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eShaderModule;
+
   public:
     VULKAN_HPP_CONSTEXPR ShaderModule()
       : m_shaderModule(VK_NULL_HANDLE)
@@ -13876,11 +14125,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( ShaderModule ) == sizeof( VkShaderModule ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eShaderModule>
+  {
+    using type = ShaderModule;
+  };
+
   class ValidationCacheEXT
   {
   public:
     using CType = VkValidationCacheEXT;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eValidationCacheEXT;
+
   public:
     VULKAN_HPP_CONSTEXPR ValidationCacheEXT()
       : m_validationCacheEXT(VK_NULL_HANDLE)
@@ -13943,11 +14200,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( ValidationCacheEXT ) == sizeof( VkValidationCacheEXT ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eValidationCacheEXT>
+  {
+    using type = ValidationCacheEXT;
+  };
+
   class Queue
   {
   public:
     using CType = VkQueue;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eQueue;
+
   public:
     VULKAN_HPP_CONSTEXPR Queue()
       : m_queue(VK_NULL_HANDLE)
@@ -14065,6 +14330,12 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( Queue ) == sizeof( VkQueue ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eQueue>
+  {
+    using type = Queue;
+  };
+
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
   class Device;
   template <typename Dispatch> class UniqueHandleTraits<AccelerationStructureNV, Dispatch> { public: using deleter = ObjectDestroy<Device, Dispatch>; };
@@ -14130,6 +14401,8 @@ namespace VULKAN_HPP_NAMESPACE
   public:
     using CType = VkDevice;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDevice;
+
   public:
     VULKAN_HPP_CONSTEXPR Device()
       : m_device(VK_NULL_HANDLE)
@@ -15731,11 +16004,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( Device ) == sizeof( VkDevice ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eDevice>
+  {
+    using type = Device;
+  };
+
   class DisplayModeKHR
   {
   public:
     using CType = VkDisplayModeKHR;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDisplayModeKHR;
+
   public:
     VULKAN_HPP_CONSTEXPR DisplayModeKHR()
       : m_displayModeKHR(VK_NULL_HANDLE)
@@ -15798,6 +16079,12 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( DisplayModeKHR ) == sizeof( VkDisplayModeKHR ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eDisplayModeKHR>
+  {
+    using type = DisplayModeKHR;
+  };
+
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch> class UniqueHandleTraits<Device, Dispatch> { public: using deleter = ObjectDestroy<NoParent, Dispatch>; };
   using UniqueDevice = UniqueHandle<Device, DispatchLoaderDefault>;
@@ -15808,6 +16095,8 @@ namespace VULKAN_HPP_NAMESPACE
   public:
     using CType = VkPhysicalDevice;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePhysicalDevice;
+
   public:
     VULKAN_HPP_CONSTEXPR PhysicalDevice()
       : m_physicalDevice(VK_NULL_HANDLE)
@@ -16395,6 +16684,12 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( PhysicalDevice ) == sizeof( VkPhysicalDevice ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::ePhysicalDevice>
+  {
+    using type = PhysicalDevice;
+  };
+
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
   class Instance;
   template <typename Dispatch> class UniqueHandleTraits<DebugReportCallbackEXT, Dispatch> { public: using deleter = ObjectDestroy<Instance, Dispatch>; };
@@ -16410,6 +16705,8 @@ namespace VULKAN_HPP_NAMESPACE
   public:
     using CType = VkInstance;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eInstance;
+
   public:
     VULKAN_HPP_CONSTEXPR Instance()
       : m_instance(VK_NULL_HANDLE)
@@ -16756,6 +17053,12 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( Instance ) == sizeof( VkInstance ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eInstance>
+  {
+    using type = Instance;
+  };
+
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
   template <typename Dispatch> class UniqueHandleTraits<Instance, Dispatch> { public: using deleter = ObjectDestroy<NoParent, Dispatch>; };
   using UniqueInstance = UniqueHandle<Instance, DispatchLoaderDefault>;