Update for Vulkan-Docs 1.3.301
diff --git a/include/vulkan/vulkan.cppm b/include/vulkan/vulkan.cppm
index 5e40ea9..65881c4 100644
--- a/include/vulkan/vulkan.cppm
+++ b/include/vulkan/vulkan.cppm
@@ -32,14 +32,17 @@
   //=====================================
   using VULKAN_HPP_NAMESPACE::ArrayWrapper1D;
   using VULKAN_HPP_NAMESPACE::ArrayWrapper2D;
-  using VULKAN_HPP_NAMESPACE::DispatchLoaderBase;
-  using VULKAN_HPP_NAMESPACE::DispatchLoaderDynamic;
   using VULKAN_HPP_NAMESPACE::Flags;
   using VULKAN_HPP_NAMESPACE::FlagTraits;
 
+  namespace detail
+  {
+    using VULKAN_HPP_NAMESPACE::detail::DispatchLoaderBase;
+    using VULKAN_HPP_NAMESPACE::detail::DispatchLoaderDynamic;
 #if !defined( VK_NO_PROTOTYPES )
-  using VULKAN_HPP_NAMESPACE::DispatchLoaderStatic;
+    using VULKAN_HPP_NAMESPACE::detail::DispatchLoaderStatic;
 #endif /*VK_NO_PROTOTYPES*/
+  }    // namespace detail
 
   using VULKAN_HPP_NAMESPACE::operator&;
   using VULKAN_HPP_NAMESPACE::operator|;
@@ -56,14 +59,18 @@
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
 #if !defined( VULKAN_HPP_NO_SMART_HANDLE )
-  using VULKAN_HPP_NAMESPACE::ObjectDestroy;
-  using VULKAN_HPP_NAMESPACE::ObjectDestroyShared;
-  using VULKAN_HPP_NAMESPACE::ObjectFree;
-  using VULKAN_HPP_NAMESPACE::ObjectFreeShared;
-  using VULKAN_HPP_NAMESPACE::ObjectRelease;
-  using VULKAN_HPP_NAMESPACE::ObjectReleaseShared;
-  using VULKAN_HPP_NAMESPACE::PoolFree;
-  using VULKAN_HPP_NAMESPACE::PoolFreeShared;
+  namespace detail
+  {
+    using VULKAN_HPP_NAMESPACE::detail::ObjectDestroy;
+    using VULKAN_HPP_NAMESPACE::detail::ObjectDestroyShared;
+    using VULKAN_HPP_NAMESPACE::detail::ObjectFree;
+    using VULKAN_HPP_NAMESPACE::detail::ObjectFreeShared;
+    using VULKAN_HPP_NAMESPACE::detail::ObjectRelease;
+    using VULKAN_HPP_NAMESPACE::detail::ObjectReleaseShared;
+    using VULKAN_HPP_NAMESPACE::detail::PoolFree;
+    using VULKAN_HPP_NAMESPACE::detail::PoolFreeShared;
+  }  // namespace detail
+
   using VULKAN_HPP_NAMESPACE::SharedHandle;
   using VULKAN_HPP_NAMESPACE::UniqueHandle;
 #endif /*VULKAN_HPP_NO_SMART_HANDLE*/
@@ -2605,6 +2612,10 @@
   using VULKAN_HPP_NAMESPACE::EXTDepthClampControlExtensionName;
   using VULKAN_HPP_NAMESPACE::EXTDepthClampControlSpecVersion;
 
+  //=== VK_HUAWEI_hdr_vivid ===
+  using VULKAN_HPP_NAMESPACE::HUAWEIHdrVividExtensionName;
+  using VULKAN_HPP_NAMESPACE::HUAWEIHdrVividSpecVersion;
+
   //=== VK_NV_cooperative_matrix2 ===
   using VULKAN_HPP_NAMESPACE::NVCooperativeMatrix2ExtensionName;
   using VULKAN_HPP_NAMESPACE::NVCooperativeMatrix2SpecVersion;
@@ -4533,6 +4544,10 @@
   using VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampControlFeaturesEXT;
   using VULKAN_HPP_NAMESPACE::PipelineViewportDepthClampControlCreateInfoEXT;
 
+  //=== VK_HUAWEI_hdr_vivid ===
+  using VULKAN_HPP_NAMESPACE::HdrVividDynamicMetadataHUAWEI;
+  using VULKAN_HPP_NAMESPACE::PhysicalDeviceHdrVividFeaturesHUAWEI;
+
   //=== VK_NV_cooperative_matrix2 ===
   using VULKAN_HPP_NAMESPACE::CooperativeMatrixFlexibleDimensionsPropertiesNV;
   using VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrix2FeaturesNV;
@@ -4883,7 +4898,10 @@
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
 #if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL
-  using VULKAN_HPP_NAMESPACE::DynamicLoader;
+  namespace detail
+  {
+    using VULKAN_HPP_NAMESPACE::detail::DynamicLoader;
+  }    // namespace detail
 #endif /*VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL*/
 
   //=====================
@@ -4933,9 +4951,13 @@
     //======================
 
     using VULKAN_HPP_RAII_NAMESPACE::Context;
-    using VULKAN_HPP_RAII_NAMESPACE::ContextDispatcher;
-    using VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher;
-    using VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher;
+
+    namespace detail
+    {
+      using VULKAN_HPP_RAII_NAMESPACE::detail::ContextDispatcher;
+      using VULKAN_HPP_RAII_NAMESPACE::detail::DeviceDispatcher;
+      using VULKAN_HPP_RAII_NAMESPACE::detail::InstanceDispatcher;
+    }  // namespace detail
 
     //====================
     //=== RAII HANDLEs ===
diff --git a/include/vulkan/vulkan.hpp b/include/vulkan/vulkan.hpp
index 1207a40..6ee70ed 100644
--- a/include/vulkan/vulkan.hpp
+++ b/include/vulkan/vulkan.hpp
@@ -63,7 +63,7 @@
 #  include <span>
 #endif
 
-static_assert( VK_HEADER_VERSION == 300, "Wrong VK_HEADER_VERSION!" );
+static_assert( VK_HEADER_VERSION == 301, "Wrong VK_HEADER_VERSION!" );
 
 // <tuple> includes <sys/sysmacros.h> through some other header
 // this results in major(x) being resolved to gnu_dev_major(x)
@@ -954,5069 +954,5093 @@
 #  endif
 #endif  // VULKAN_HPP_DISABLE_ENHANCED_MODE
 
-  class DispatchLoaderBase
+  namespace detail
   {
-  public:
-    DispatchLoaderBase() = default;
-    DispatchLoaderBase( std::nullptr_t )
-#if !defined( NDEBUG )
-      : m_valid( false )
-#endif
+    class DispatchLoaderBase
     {
-    }
+    public:
+      DispatchLoaderBase() = default;
+      DispatchLoaderBase( std::nullptr_t )
+#if !defined( NDEBUG )
+        : m_valid( false )
+#endif
+      {
+      }
 
 #if !defined( NDEBUG )
-    size_t getVkHeaderVersion() const
-    {
-      VULKAN_HPP_ASSERT( m_valid );
-      return vkHeaderVersion;
-    }
+      size_t getVkHeaderVersion() const
+      {
+        VULKAN_HPP_ASSERT( m_valid );
+        return vkHeaderVersion;
+      }
 
-  private:
-    size_t vkHeaderVersion = VK_HEADER_VERSION;
-    bool   m_valid         = true;
+    private:
+      size_t vkHeaderVersion = VK_HEADER_VERSION;
+      bool   m_valid         = true;
 #endif
-  };
+    };
 
 #if !defined( VK_NO_PROTOTYPES )
-  class DispatchLoaderStatic : public DispatchLoaderBase
-  {
-  public:
-    //=== VK_VERSION_1_0 ===
-
-    VkResult
-      vkCreateInstance( const VkInstanceCreateInfo * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkInstance * pInstance ) const VULKAN_HPP_NOEXCEPT
+    class DispatchLoaderStatic : public DispatchLoaderBase
     {
-      return ::vkCreateInstance( pCreateInfo, pAllocator, pInstance );
-    }
+    public:
+      //=== VK_VERSION_1_0 ===
 
-    void vkDestroyInstance( VkInstance instance, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkDestroyInstance( instance, pAllocator );
-    }
+      VkResult
+        vkCreateInstance( const VkInstanceCreateInfo * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkInstance * pInstance ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateInstance( pCreateInfo, pAllocator, pInstance );
+      }
 
-    VkResult vkEnumeratePhysicalDevices( VkInstance instance, uint32_t * pPhysicalDeviceCount, VkPhysicalDevice * pPhysicalDevices ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkEnumeratePhysicalDevices( instance, pPhysicalDeviceCount, pPhysicalDevices );
-    }
+      void vkDestroyInstance( VkInstance instance, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkDestroyInstance( instance, pAllocator );
+      }
 
-    void vkGetPhysicalDeviceFeatures( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures * pFeatures ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceFeatures( physicalDevice, pFeatures );
-    }
+      VkResult vkEnumeratePhysicalDevices( VkInstance instance, uint32_t * pPhysicalDeviceCount, VkPhysicalDevice * pPhysicalDevices ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkEnumeratePhysicalDevices( instance, pPhysicalDeviceCount, pPhysicalDevices );
+      }
 
-    void
-      vkGetPhysicalDeviceFormatProperties( VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties * pFormatProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceFormatProperties( physicalDevice, format, pFormatProperties );
-    }
+      void vkGetPhysicalDeviceFeatures( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures * pFeatures ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceFeatures( physicalDevice, pFeatures );
+      }
 
-    VkResult vkGetPhysicalDeviceImageFormatProperties( VkPhysicalDevice          physicalDevice,
-                                                       VkFormat                  format,
-                                                       VkImageType               type,
-                                                       VkImageTiling             tiling,
-                                                       VkImageUsageFlags         usage,
-                                                       VkImageCreateFlags        flags,
-                                                       VkImageFormatProperties * pImageFormatProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceImageFormatProperties( physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties );
-    }
+      void vkGetPhysicalDeviceFormatProperties( VkPhysicalDevice     physicalDevice,
+                                                VkFormat             format,
+                                                VkFormatProperties * pFormatProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceFormatProperties( physicalDevice, format, pFormatProperties );
+      }
 
-    void vkGetPhysicalDeviceProperties( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties * pProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceProperties( physicalDevice, pProperties );
-    }
+      VkResult vkGetPhysicalDeviceImageFormatProperties( VkPhysicalDevice          physicalDevice,
+                                                         VkFormat                  format,
+                                                         VkImageType               type,
+                                                         VkImageTiling             tiling,
+                                                         VkImageUsageFlags         usage,
+                                                         VkImageCreateFlags        flags,
+                                                         VkImageFormatProperties * pImageFormatProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceImageFormatProperties( physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties );
+      }
 
-    void vkGetPhysicalDeviceQueueFamilyProperties( VkPhysicalDevice          physicalDevice,
-                                                   uint32_t *                pQueueFamilyPropertyCount,
-                                                   VkQueueFamilyProperties * pQueueFamilyProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceQueueFamilyProperties( physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties );
-    }
+      void vkGetPhysicalDeviceProperties( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties * pProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceProperties( physicalDevice, pProperties );
+      }
 
-    void vkGetPhysicalDeviceMemoryProperties( VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties * pMemoryProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceMemoryProperties( physicalDevice, pMemoryProperties );
-    }
+      void vkGetPhysicalDeviceQueueFamilyProperties( VkPhysicalDevice          physicalDevice,
+                                                     uint32_t *                pQueueFamilyPropertyCount,
+                                                     VkQueueFamilyProperties * pQueueFamilyProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceQueueFamilyProperties( physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties );
+      }
 
-    PFN_vkVoidFunction vkGetInstanceProcAddr( VkInstance instance, const char * pName ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetInstanceProcAddr( instance, pName );
-    }
+      void vkGetPhysicalDeviceMemoryProperties( VkPhysicalDevice                   physicalDevice,
+                                                VkPhysicalDeviceMemoryProperties * pMemoryProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceMemoryProperties( physicalDevice, pMemoryProperties );
+      }
 
-    PFN_vkVoidFunction vkGetDeviceProcAddr( VkDevice device, const char * pName ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetDeviceProcAddr( device, pName );
-    }
+      PFN_vkVoidFunction vkGetInstanceProcAddr( VkInstance instance, const char * pName ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetInstanceProcAddr( instance, pName );
+      }
 
-    VkResult vkCreateDevice( VkPhysicalDevice              physicalDevice,
-                             const VkDeviceCreateInfo *    pCreateInfo,
-                             const VkAllocationCallbacks * pAllocator,
-                             VkDevice *                    pDevice ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateDevice( physicalDevice, pCreateInfo, pAllocator, pDevice );
-    }
+      PFN_vkVoidFunction vkGetDeviceProcAddr( VkDevice device, const char * pName ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetDeviceProcAddr( device, pName );
+      }
 
-    void vkDestroyDevice( VkDevice device, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkDestroyDevice( device, pAllocator );
-    }
+      VkResult vkCreateDevice( VkPhysicalDevice              physicalDevice,
+                               const VkDeviceCreateInfo *    pCreateInfo,
+                               const VkAllocationCallbacks * pAllocator,
+                               VkDevice *                    pDevice ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateDevice( physicalDevice, pCreateInfo, pAllocator, pDevice );
+      }
 
-    VkResult vkEnumerateInstanceExtensionProperties( const char *            pLayerName,
+      void vkDestroyDevice( VkDevice device, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkDestroyDevice( device, pAllocator );
+      }
+
+      VkResult vkEnumerateInstanceExtensionProperties( const char *            pLayerName,
+                                                       uint32_t *              pPropertyCount,
+                                                       VkExtensionProperties * pProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkEnumerateInstanceExtensionProperties( pLayerName, pPropertyCount, pProperties );
+      }
+
+      VkResult vkEnumerateDeviceExtensionProperties( VkPhysicalDevice        physicalDevice,
+                                                     const char *            pLayerName,
                                                      uint32_t *              pPropertyCount,
                                                      VkExtensionProperties * pProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkEnumerateInstanceExtensionProperties( pLayerName, pPropertyCount, pProperties );
-    }
+      {
+        return ::vkEnumerateDeviceExtensionProperties( physicalDevice, pLayerName, pPropertyCount, pProperties );
+      }
 
-    VkResult vkEnumerateDeviceExtensionProperties( VkPhysicalDevice        physicalDevice,
-                                                   const char *            pLayerName,
-                                                   uint32_t *              pPropertyCount,
-                                                   VkExtensionProperties * pProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkEnumerateDeviceExtensionProperties( physicalDevice, pLayerName, pPropertyCount, pProperties );
-    }
+      VkResult vkEnumerateInstanceLayerProperties( uint32_t * pPropertyCount, VkLayerProperties * pProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkEnumerateInstanceLayerProperties( pPropertyCount, pProperties );
+      }
 
-    VkResult vkEnumerateInstanceLayerProperties( uint32_t * pPropertyCount, VkLayerProperties * pProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkEnumerateInstanceLayerProperties( pPropertyCount, pProperties );
-    }
+      VkResult vkEnumerateDeviceLayerProperties( VkPhysicalDevice    physicalDevice,
+                                                 uint32_t *          pPropertyCount,
+                                                 VkLayerProperties * pProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkEnumerateDeviceLayerProperties( physicalDevice, pPropertyCount, pProperties );
+      }
 
-    VkResult
-      vkEnumerateDeviceLayerProperties( VkPhysicalDevice physicalDevice, uint32_t * pPropertyCount, VkLayerProperties * pProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkEnumerateDeviceLayerProperties( physicalDevice, pPropertyCount, pProperties );
-    }
+      void vkGetDeviceQueue( VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue * pQueue ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetDeviceQueue( device, queueFamilyIndex, queueIndex, pQueue );
+      }
 
-    void vkGetDeviceQueue( VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue * pQueue ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetDeviceQueue( device, queueFamilyIndex, queueIndex, pQueue );
-    }
+      VkResult vkQueueSubmit( VkQueue queue, uint32_t submitCount, const VkSubmitInfo * pSubmits, VkFence fence ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkQueueSubmit( queue, submitCount, pSubmits, fence );
+      }
 
-    VkResult vkQueueSubmit( VkQueue queue, uint32_t submitCount, const VkSubmitInfo * pSubmits, VkFence fence ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkQueueSubmit( queue, submitCount, pSubmits, fence );
-    }
+      VkResult vkQueueWaitIdle( VkQueue queue ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkQueueWaitIdle( queue );
+      }
 
-    VkResult vkQueueWaitIdle( VkQueue queue ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkQueueWaitIdle( queue );
-    }
+      VkResult vkDeviceWaitIdle( VkDevice device ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkDeviceWaitIdle( device );
+      }
 
-    VkResult vkDeviceWaitIdle( VkDevice device ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkDeviceWaitIdle( device );
-    }
+      VkResult vkAllocateMemory( VkDevice                      device,
+                                 const VkMemoryAllocateInfo *  pAllocateInfo,
+                                 const VkAllocationCallbacks * pAllocator,
+                                 VkDeviceMemory *              pMemory ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkAllocateMemory( device, pAllocateInfo, pAllocator, pMemory );
+      }
 
-    VkResult vkAllocateMemory( VkDevice                      device,
-                               const VkMemoryAllocateInfo *  pAllocateInfo,
-                               const VkAllocationCallbacks * pAllocator,
-                               VkDeviceMemory *              pMemory ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkAllocateMemory( device, pAllocateInfo, pAllocator, pMemory );
-    }
+      void vkFreeMemory( VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkFreeMemory( device, memory, pAllocator );
+      }
 
-    void vkFreeMemory( VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkFreeMemory( device, memory, pAllocator );
-    }
+      VkResult vkMapMemory( VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void ** ppData ) const
+        VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkMapMemory( device, memory, offset, size, flags, ppData );
+      }
 
-    VkResult vkMapMemory( VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void ** ppData ) const
-      VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkMapMemory( device, memory, offset, size, flags, ppData );
-    }
+      void vkUnmapMemory( VkDevice device, VkDeviceMemory memory ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkUnmapMemory( device, memory );
+      }
 
-    void vkUnmapMemory( VkDevice device, VkDeviceMemory memory ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkUnmapMemory( device, memory );
-    }
+      VkResult vkFlushMappedMemoryRanges( VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange * pMemoryRanges ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkFlushMappedMemoryRanges( device, memoryRangeCount, pMemoryRanges );
+      }
 
-    VkResult vkFlushMappedMemoryRanges( VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange * pMemoryRanges ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkFlushMappedMemoryRanges( device, memoryRangeCount, pMemoryRanges );
-    }
+      VkResult vkInvalidateMappedMemoryRanges( VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange * pMemoryRanges ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkInvalidateMappedMemoryRanges( device, memoryRangeCount, pMemoryRanges );
+      }
 
-    VkResult vkInvalidateMappedMemoryRanges( VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange * pMemoryRanges ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkInvalidateMappedMemoryRanges( device, memoryRangeCount, pMemoryRanges );
-    }
+      void vkGetDeviceMemoryCommitment( VkDevice device, VkDeviceMemory memory, VkDeviceSize * pCommittedMemoryInBytes ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetDeviceMemoryCommitment( device, memory, pCommittedMemoryInBytes );
+      }
 
-    void vkGetDeviceMemoryCommitment( VkDevice device, VkDeviceMemory memory, VkDeviceSize * pCommittedMemoryInBytes ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetDeviceMemoryCommitment( device, memory, pCommittedMemoryInBytes );
-    }
+      VkResult vkBindBufferMemory( VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkBindBufferMemory( device, buffer, memory, memoryOffset );
+      }
 
-    VkResult vkBindBufferMemory( VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkBindBufferMemory( device, buffer, memory, memoryOffset );
-    }
+      VkResult vkBindImageMemory( VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkBindImageMemory( device, image, memory, memoryOffset );
+      }
 
-    VkResult vkBindImageMemory( VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkBindImageMemory( device, image, memory, memoryOffset );
-    }
+      void vkGetBufferMemoryRequirements( VkDevice device, VkBuffer buffer, VkMemoryRequirements * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetBufferMemoryRequirements( device, buffer, pMemoryRequirements );
+      }
 
-    void vkGetBufferMemoryRequirements( VkDevice device, VkBuffer buffer, VkMemoryRequirements * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetBufferMemoryRequirements( device, buffer, pMemoryRequirements );
-    }
+      void vkGetImageMemoryRequirements( VkDevice device, VkImage image, VkMemoryRequirements * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetImageMemoryRequirements( device, image, pMemoryRequirements );
+      }
 
-    void vkGetImageMemoryRequirements( VkDevice device, VkImage image, VkMemoryRequirements * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetImageMemoryRequirements( device, image, pMemoryRequirements );
-    }
+      void vkGetImageSparseMemoryRequirements( VkDevice                          device,
+                                               VkImage                           image,
+                                               uint32_t *                        pSparseMemoryRequirementCount,
+                                               VkSparseImageMemoryRequirements * pSparseMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetImageSparseMemoryRequirements( device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements );
+      }
 
-    void vkGetImageSparseMemoryRequirements( VkDevice                          device,
-                                             VkImage                           image,
-                                             uint32_t *                        pSparseMemoryRequirementCount,
-                                             VkSparseImageMemoryRequirements * pSparseMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetImageSparseMemoryRequirements( device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements );
-    }
+      void vkGetPhysicalDeviceSparseImageFormatProperties( VkPhysicalDevice                physicalDevice,
+                                                           VkFormat                        format,
+                                                           VkImageType                     type,
+                                                           VkSampleCountFlagBits           samples,
+                                                           VkImageUsageFlags               usage,
+                                                           VkImageTiling                   tiling,
+                                                           uint32_t *                      pPropertyCount,
+                                                           VkSparseImageFormatProperties * pProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceSparseImageFormatProperties( physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties );
+      }
 
-    void vkGetPhysicalDeviceSparseImageFormatProperties( VkPhysicalDevice                physicalDevice,
-                                                         VkFormat                        format,
-                                                         VkImageType                     type,
-                                                         VkSampleCountFlagBits           samples,
-                                                         VkImageUsageFlags               usage,
-                                                         VkImageTiling                   tiling,
-                                                         uint32_t *                      pPropertyCount,
-                                                         VkSparseImageFormatProperties * pProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceSparseImageFormatProperties( physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties );
-    }
+      VkResult vkQueueBindSparse( VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo * pBindInfo, VkFence fence ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkQueueBindSparse( queue, bindInfoCount, pBindInfo, fence );
+      }
 
-    VkResult vkQueueBindSparse( VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo * pBindInfo, VkFence fence ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkQueueBindSparse( queue, bindInfoCount, pBindInfo, fence );
-    }
-
-    VkResult vkCreateFence( VkDevice                      device,
-                            const VkFenceCreateInfo *     pCreateInfo,
-                            const VkAllocationCallbacks * pAllocator,
-                            VkFence *                     pFence ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateFence( device, pCreateInfo, pAllocator, pFence );
-    }
-
-    void vkDestroyFence( VkDevice device, VkFence fence, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkDestroyFence( device, fence, pAllocator );
-    }
-
-    VkResult vkResetFences( VkDevice device, uint32_t fenceCount, const VkFence * pFences ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkResetFences( device, fenceCount, pFences );
-    }
-
-    VkResult vkGetFenceStatus( VkDevice device, VkFence fence ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetFenceStatus( device, fence );
-    }
-
-    VkResult vkWaitForFences( VkDevice device, uint32_t fenceCount, const VkFence * pFences, VkBool32 waitAll, uint64_t timeout ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkWaitForFences( device, fenceCount, pFences, waitAll, timeout );
-    }
-
-    VkResult vkCreateSemaphore( VkDevice                      device,
-                                const VkSemaphoreCreateInfo * pCreateInfo,
-                                const VkAllocationCallbacks * pAllocator,
-                                VkSemaphore *                 pSemaphore ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateSemaphore( device, pCreateInfo, pAllocator, pSemaphore );
-    }
-
-    void vkDestroySemaphore( VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkDestroySemaphore( device, semaphore, pAllocator );
-    }
-
-    VkResult vkCreateEvent( VkDevice                      device,
-                            const VkEventCreateInfo *     pCreateInfo,
-                            const VkAllocationCallbacks * pAllocator,
-                            VkEvent *                     pEvent ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateEvent( device, pCreateInfo, pAllocator, pEvent );
-    }
-
-    void vkDestroyEvent( VkDevice device, VkEvent event, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkDestroyEvent( device, event, pAllocator );
-    }
-
-    VkResult vkGetEventStatus( VkDevice device, VkEvent event ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetEventStatus( device, event );
-    }
-
-    VkResult vkSetEvent( VkDevice device, VkEvent event ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkSetEvent( device, event );
-    }
-
-    VkResult vkResetEvent( VkDevice device, VkEvent event ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkResetEvent( device, event );
-    }
-
-    VkResult vkCreateQueryPool( VkDevice                      device,
-                                const VkQueryPoolCreateInfo * pCreateInfo,
-                                const VkAllocationCallbacks * pAllocator,
-                                VkQueryPool *                 pQueryPool ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateQueryPool( device, pCreateInfo, pAllocator, pQueryPool );
-    }
-
-    void vkDestroyQueryPool( VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkDestroyQueryPool( device, queryPool, pAllocator );
-    }
-
-    VkResult vkGetQueryPoolResults( VkDevice           device,
-                                    VkQueryPool        queryPool,
-                                    uint32_t           firstQuery,
-                                    uint32_t           queryCount,
-                                    size_t             dataSize,
-                                    void *             pData,
-                                    VkDeviceSize       stride,
-                                    VkQueryResultFlags flags ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetQueryPoolResults( device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags );
-    }
-
-    VkResult vkCreateBuffer( VkDevice                      device,
-                             const VkBufferCreateInfo *    pCreateInfo,
-                             const VkAllocationCallbacks * pAllocator,
-                             VkBuffer *                    pBuffer ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateBuffer( device, pCreateInfo, pAllocator, pBuffer );
-    }
-
-    void vkDestroyBuffer( VkDevice device, VkBuffer buffer, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkDestroyBuffer( device, buffer, pAllocator );
-    }
-
-    VkResult vkCreateBufferView( VkDevice                       device,
-                                 const VkBufferViewCreateInfo * pCreateInfo,
-                                 const VkAllocationCallbacks *  pAllocator,
-                                 VkBufferView *                 pView ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateBufferView( device, pCreateInfo, pAllocator, pView );
-    }
-
-    void vkDestroyBufferView( VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkDestroyBufferView( device, bufferView, pAllocator );
-    }
-
-    VkResult vkCreateImage( VkDevice                      device,
-                            const VkImageCreateInfo *     pCreateInfo,
-                            const VkAllocationCallbacks * pAllocator,
-                            VkImage *                     pImage ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateImage( device, pCreateInfo, pAllocator, pImage );
-    }
-
-    void vkDestroyImage( VkDevice device, VkImage image, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkDestroyImage( device, image, pAllocator );
-    }
-
-    void vkGetImageSubresourceLayout( VkDevice                   device,
-                                      VkImage                    image,
-                                      const VkImageSubresource * pSubresource,
-                                      VkSubresourceLayout *      pLayout ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetImageSubresourceLayout( device, image, pSubresource, pLayout );
-    }
-
-    VkResult vkCreateImageView( VkDevice                      device,
-                                const VkImageViewCreateInfo * pCreateInfo,
-                                const VkAllocationCallbacks * pAllocator,
-                                VkImageView *                 pView ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateImageView( device, pCreateInfo, pAllocator, pView );
-    }
-
-    void vkDestroyImageView( VkDevice device, VkImageView imageView, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkDestroyImageView( device, imageView, pAllocator );
-    }
-
-    VkResult vkCreateShaderModule( VkDevice                         device,
-                                   const VkShaderModuleCreateInfo * pCreateInfo,
-                                   const VkAllocationCallbacks *    pAllocator,
-                                   VkShaderModule *                 pShaderModule ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateShaderModule( device, pCreateInfo, pAllocator, pShaderModule );
-    }
-
-    void vkDestroyShaderModule( VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkDestroyShaderModule( device, shaderModule, pAllocator );
-    }
-
-    VkResult vkCreatePipelineCache( VkDevice                          device,
-                                    const VkPipelineCacheCreateInfo * pCreateInfo,
-                                    const VkAllocationCallbacks *     pAllocator,
-                                    VkPipelineCache *                 pPipelineCache ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreatePipelineCache( device, pCreateInfo, pAllocator, pPipelineCache );
-    }
-
-    void vkDestroyPipelineCache( VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkDestroyPipelineCache( device, pipelineCache, pAllocator );
-    }
-
-    VkResult vkGetPipelineCacheData( VkDevice device, VkPipelineCache pipelineCache, size_t * pDataSize, void * pData ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPipelineCacheData( device, pipelineCache, pDataSize, pData );
-    }
-
-    VkResult
-      vkMergePipelineCaches( VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache * pSrcCaches ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkMergePipelineCaches( device, dstCache, srcCacheCount, pSrcCaches );
-    }
-
-    VkResult vkCreateGraphicsPipelines( VkDevice                             device,
-                                        VkPipelineCache                      pipelineCache,
-                                        uint32_t                             createInfoCount,
-                                        const VkGraphicsPipelineCreateInfo * pCreateInfos,
-                                        const VkAllocationCallbacks *        pAllocator,
-                                        VkPipeline *                         pPipelines ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateGraphicsPipelines( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines );
-    }
-
-    VkResult vkCreateComputePipelines( VkDevice                            device,
-                                       VkPipelineCache                     pipelineCache,
-                                       uint32_t                            createInfoCount,
-                                       const VkComputePipelineCreateInfo * pCreateInfos,
-                                       const VkAllocationCallbacks *       pAllocator,
-                                       VkPipeline *                        pPipelines ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateComputePipelines( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines );
-    }
-
-    void vkDestroyPipeline( VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkDestroyPipeline( device, pipeline, pAllocator );
-    }
-
-    VkResult vkCreatePipelineLayout( VkDevice                           device,
-                                     const VkPipelineLayoutCreateInfo * pCreateInfo,
-                                     const VkAllocationCallbacks *      pAllocator,
-                                     VkPipelineLayout *                 pPipelineLayout ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreatePipelineLayout( device, pCreateInfo, pAllocator, pPipelineLayout );
-    }
-
-    void vkDestroyPipelineLayout( VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkDestroyPipelineLayout( device, pipelineLayout, pAllocator );
-    }
-
-    VkResult vkCreateSampler( VkDevice                      device,
-                              const VkSamplerCreateInfo *   pCreateInfo,
+      VkResult vkCreateFence( VkDevice                      device,
+                              const VkFenceCreateInfo *     pCreateInfo,
                               const VkAllocationCallbacks * pAllocator,
-                              VkSampler *                   pSampler ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateSampler( device, pCreateInfo, pAllocator, pSampler );
-    }
+                              VkFence *                     pFence ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateFence( device, pCreateInfo, pAllocator, pFence );
+      }
 
-    void vkDestroySampler( VkDevice device, VkSampler sampler, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkDestroySampler( device, sampler, pAllocator );
-    }
+      void vkDestroyFence( VkDevice device, VkFence fence, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkDestroyFence( device, fence, pAllocator );
+      }
 
-    VkResult vkCreateDescriptorSetLayout( VkDevice                                device,
-                                          const VkDescriptorSetLayoutCreateInfo * pCreateInfo,
-                                          const VkAllocationCallbacks *           pAllocator,
-                                          VkDescriptorSetLayout *                 pSetLayout ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateDescriptorSetLayout( device, pCreateInfo, pAllocator, pSetLayout );
-    }
+      VkResult vkResetFences( VkDevice device, uint32_t fenceCount, const VkFence * pFences ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkResetFences( device, fenceCount, pFences );
+      }
 
-    void vkDestroyDescriptorSetLayout( VkDevice                      device,
-                                       VkDescriptorSetLayout         descriptorSetLayout,
-                                       const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkDestroyDescriptorSetLayout( device, descriptorSetLayout, pAllocator );
-    }
+      VkResult vkGetFenceStatus( VkDevice device, VkFence fence ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetFenceStatus( device, fence );
+      }
 
-    VkResult vkCreateDescriptorPool( VkDevice                           device,
-                                     const VkDescriptorPoolCreateInfo * pCreateInfo,
-                                     const VkAllocationCallbacks *      pAllocator,
-                                     VkDescriptorPool *                 pDescriptorPool ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateDescriptorPool( device, pCreateInfo, pAllocator, pDescriptorPool );
-    }
+      VkResult vkWaitForFences( VkDevice device, uint32_t fenceCount, const VkFence * pFences, VkBool32 waitAll, uint64_t timeout ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkWaitForFences( device, fenceCount, pFences, waitAll, timeout );
+      }
 
-    void vkDestroyDescriptorPool( VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkDestroyDescriptorPool( device, descriptorPool, pAllocator );
-    }
+      VkResult vkCreateSemaphore( VkDevice                      device,
+                                  const VkSemaphoreCreateInfo * pCreateInfo,
+                                  const VkAllocationCallbacks * pAllocator,
+                                  VkSemaphore *                 pSemaphore ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateSemaphore( device, pCreateInfo, pAllocator, pSemaphore );
+      }
 
-    VkResult vkResetDescriptorPool( VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkResetDescriptorPool( device, descriptorPool, flags );
-    }
+      void vkDestroySemaphore( VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkDestroySemaphore( device, semaphore, pAllocator );
+      }
 
-    VkResult vkAllocateDescriptorSets( VkDevice                            device,
-                                       const VkDescriptorSetAllocateInfo * pAllocateInfo,
-                                       VkDescriptorSet *                   pDescriptorSets ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkAllocateDescriptorSets( device, pAllocateInfo, pDescriptorSets );
-    }
+      VkResult vkCreateEvent( VkDevice                      device,
+                              const VkEventCreateInfo *     pCreateInfo,
+                              const VkAllocationCallbacks * pAllocator,
+                              VkEvent *                     pEvent ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateEvent( device, pCreateInfo, pAllocator, pEvent );
+      }
 
-    VkResult vkFreeDescriptorSets( VkDevice                device,
-                                   VkDescriptorPool        descriptorPool,
-                                   uint32_t                descriptorSetCount,
-                                   const VkDescriptorSet * pDescriptorSets ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkFreeDescriptorSets( device, descriptorPool, descriptorSetCount, pDescriptorSets );
-    }
+      void vkDestroyEvent( VkDevice device, VkEvent event, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkDestroyEvent( device, event, pAllocator );
+      }
 
-    void vkUpdateDescriptorSets( VkDevice                     device,
-                                 uint32_t                     descriptorWriteCount,
-                                 const VkWriteDescriptorSet * pDescriptorWrites,
-                                 uint32_t                     descriptorCopyCount,
-                                 const VkCopyDescriptorSet *  pDescriptorCopies ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkUpdateDescriptorSets( device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies );
-    }
+      VkResult vkGetEventStatus( VkDevice device, VkEvent event ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetEventStatus( device, event );
+      }
 
-    VkResult vkCreateFramebuffer( VkDevice                        device,
-                                  const VkFramebufferCreateInfo * pCreateInfo,
-                                  const VkAllocationCallbacks *   pAllocator,
-                                  VkFramebuffer *                 pFramebuffer ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateFramebuffer( device, pCreateInfo, pAllocator, pFramebuffer );
-    }
+      VkResult vkSetEvent( VkDevice device, VkEvent event ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkSetEvent( device, event );
+      }
 
-    void vkDestroyFramebuffer( VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkDestroyFramebuffer( device, framebuffer, pAllocator );
-    }
+      VkResult vkResetEvent( VkDevice device, VkEvent event ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkResetEvent( device, event );
+      }
 
-    VkResult vkCreateRenderPass( VkDevice                       device,
-                                 const VkRenderPassCreateInfo * pCreateInfo,
-                                 const VkAllocationCallbacks *  pAllocator,
-                                 VkRenderPass *                 pRenderPass ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateRenderPass( device, pCreateInfo, pAllocator, pRenderPass );
-    }
+      VkResult vkCreateQueryPool( VkDevice                      device,
+                                  const VkQueryPoolCreateInfo * pCreateInfo,
+                                  const VkAllocationCallbacks * pAllocator,
+                                  VkQueryPool *                 pQueryPool ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateQueryPool( device, pCreateInfo, pAllocator, pQueryPool );
+      }
 
-    void vkDestroyRenderPass( VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkDestroyRenderPass( device, renderPass, pAllocator );
-    }
+      void vkDestroyQueryPool( VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkDestroyQueryPool( device, queryPool, pAllocator );
+      }
 
-    void vkGetRenderAreaGranularity( VkDevice device, VkRenderPass renderPass, VkExtent2D * pGranularity ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetRenderAreaGranularity( device, renderPass, pGranularity );
-    }
+      VkResult vkGetQueryPoolResults( VkDevice           device,
+                                      VkQueryPool        queryPool,
+                                      uint32_t           firstQuery,
+                                      uint32_t           queryCount,
+                                      size_t             dataSize,
+                                      void *             pData,
+                                      VkDeviceSize       stride,
+                                      VkQueryResultFlags flags ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetQueryPoolResults( device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags );
+      }
 
-    VkResult vkCreateCommandPool( VkDevice                        device,
-                                  const VkCommandPoolCreateInfo * pCreateInfo,
-                                  const VkAllocationCallbacks *   pAllocator,
-                                  VkCommandPool *                 pCommandPool ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateCommandPool( device, pCreateInfo, pAllocator, pCommandPool );
-    }
+      VkResult vkCreateBuffer( VkDevice                      device,
+                               const VkBufferCreateInfo *    pCreateInfo,
+                               const VkAllocationCallbacks * pAllocator,
+                               VkBuffer *                    pBuffer ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateBuffer( device, pCreateInfo, pAllocator, pBuffer );
+      }
 
-    void vkDestroyCommandPool( VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkDestroyCommandPool( device, commandPool, pAllocator );
-    }
+      void vkDestroyBuffer( VkDevice device, VkBuffer buffer, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkDestroyBuffer( device, buffer, pAllocator );
+      }
 
-    VkResult vkResetCommandPool( VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkResetCommandPool( device, commandPool, flags );
-    }
+      VkResult vkCreateBufferView( VkDevice                       device,
+                                   const VkBufferViewCreateInfo * pCreateInfo,
+                                   const VkAllocationCallbacks *  pAllocator,
+                                   VkBufferView *                 pView ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateBufferView( device, pCreateInfo, pAllocator, pView );
+      }
 
-    VkResult vkAllocateCommandBuffers( VkDevice                            device,
-                                       const VkCommandBufferAllocateInfo * pAllocateInfo,
-                                       VkCommandBuffer *                   pCommandBuffers ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkAllocateCommandBuffers( device, pAllocateInfo, pCommandBuffers );
-    }
+      void vkDestroyBufferView( VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkDestroyBufferView( device, bufferView, pAllocator );
+      }
 
-    void vkFreeCommandBuffers( VkDevice                device,
-                               VkCommandPool           commandPool,
-                               uint32_t                commandBufferCount,
-                               const VkCommandBuffer * pCommandBuffers ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkFreeCommandBuffers( device, commandPool, commandBufferCount, pCommandBuffers );
-    }
+      VkResult vkCreateImage( VkDevice                      device,
+                              const VkImageCreateInfo *     pCreateInfo,
+                              const VkAllocationCallbacks * pAllocator,
+                              VkImage *                     pImage ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateImage( device, pCreateInfo, pAllocator, pImage );
+      }
 
-    VkResult vkBeginCommandBuffer( VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo * pBeginInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkBeginCommandBuffer( commandBuffer, pBeginInfo );
-    }
+      void vkDestroyImage( VkDevice device, VkImage image, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkDestroyImage( device, image, pAllocator );
+      }
 
-    VkResult vkEndCommandBuffer( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkEndCommandBuffer( commandBuffer );
-    }
+      void vkGetImageSubresourceLayout( VkDevice                   device,
+                                        VkImage                    image,
+                                        const VkImageSubresource * pSubresource,
+                                        VkSubresourceLayout *      pLayout ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetImageSubresourceLayout( device, image, pSubresource, pLayout );
+      }
 
-    VkResult vkResetCommandBuffer( VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkResetCommandBuffer( commandBuffer, flags );
-    }
+      VkResult vkCreateImageView( VkDevice                      device,
+                                  const VkImageViewCreateInfo * pCreateInfo,
+                                  const VkAllocationCallbacks * pAllocator,
+                                  VkImageView *                 pView ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateImageView( device, pCreateInfo, pAllocator, pView );
+      }
 
-    void vkCmdBindPipeline( VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdBindPipeline( commandBuffer, pipelineBindPoint, pipeline );
-    }
+      void vkDestroyImageView( VkDevice device, VkImageView imageView, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkDestroyImageView( device, imageView, pAllocator );
+      }
 
-    void
-      vkCmdSetViewport( VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport * pViewports ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetViewport( commandBuffer, firstViewport, viewportCount, pViewports );
-    }
+      VkResult vkCreateShaderModule( VkDevice                         device,
+                                     const VkShaderModuleCreateInfo * pCreateInfo,
+                                     const VkAllocationCallbacks *    pAllocator,
+                                     VkShaderModule *                 pShaderModule ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateShaderModule( device, pCreateInfo, pAllocator, pShaderModule );
+      }
 
-    void vkCmdSetScissor( VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D * pScissors ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetScissor( commandBuffer, firstScissor, scissorCount, pScissors );
-    }
+      void vkDestroyShaderModule( VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkDestroyShaderModule( device, shaderModule, pAllocator );
+      }
 
-    void vkCmdSetLineWidth( VkCommandBuffer commandBuffer, float lineWidth ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetLineWidth( commandBuffer, lineWidth );
-    }
+      VkResult vkCreatePipelineCache( VkDevice                          device,
+                                      const VkPipelineCacheCreateInfo * pCreateInfo,
+                                      const VkAllocationCallbacks *     pAllocator,
+                                      VkPipelineCache *                 pPipelineCache ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreatePipelineCache( device, pCreateInfo, pAllocator, pPipelineCache );
+      }
 
-    void vkCmdSetDepthBias( VkCommandBuffer commandBuffer,
-                            float           depthBiasConstantFactor,
-                            float           depthBiasClamp,
-                            float           depthBiasSlopeFactor ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetDepthBias( commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor );
-    }
+      void vkDestroyPipelineCache( VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkDestroyPipelineCache( device, pipelineCache, pAllocator );
+      }
 
-    void vkCmdSetBlendConstants( VkCommandBuffer commandBuffer, const float blendConstants[4] ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetBlendConstants( commandBuffer, blendConstants );
-    }
+      VkResult vkGetPipelineCacheData( VkDevice device, VkPipelineCache pipelineCache, size_t * pDataSize, void * pData ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPipelineCacheData( device, pipelineCache, pDataSize, pData );
+      }
 
-    void vkCmdSetDepthBounds( VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetDepthBounds( commandBuffer, minDepthBounds, maxDepthBounds );
-    }
+      VkResult
+        vkMergePipelineCaches( VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache * pSrcCaches ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkMergePipelineCaches( device, dstCache, srcCacheCount, pSrcCaches );
+      }
 
-    void vkCmdSetStencilCompareMask( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetStencilCompareMask( commandBuffer, faceMask, compareMask );
-    }
+      VkResult vkCreateGraphicsPipelines( VkDevice                             device,
+                                          VkPipelineCache                      pipelineCache,
+                                          uint32_t                             createInfoCount,
+                                          const VkGraphicsPipelineCreateInfo * pCreateInfos,
+                                          const VkAllocationCallbacks *        pAllocator,
+                                          VkPipeline *                         pPipelines ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateGraphicsPipelines( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines );
+      }
 
-    void vkCmdSetStencilWriteMask( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetStencilWriteMask( commandBuffer, faceMask, writeMask );
-    }
+      VkResult vkCreateComputePipelines( VkDevice                            device,
+                                         VkPipelineCache                     pipelineCache,
+                                         uint32_t                            createInfoCount,
+                                         const VkComputePipelineCreateInfo * pCreateInfos,
+                                         const VkAllocationCallbacks *       pAllocator,
+                                         VkPipeline *                        pPipelines ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateComputePipelines( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines );
+      }
 
-    void vkCmdSetStencilReference( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetStencilReference( commandBuffer, faceMask, reference );
-    }
+      void vkDestroyPipeline( VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkDestroyPipeline( device, pipeline, pAllocator );
+      }
 
-    void vkCmdBindDescriptorSets( VkCommandBuffer         commandBuffer,
-                                  VkPipelineBindPoint     pipelineBindPoint,
-                                  VkPipelineLayout        layout,
-                                  uint32_t                firstSet,
-                                  uint32_t                descriptorSetCount,
-                                  const VkDescriptorSet * pDescriptorSets,
-                                  uint32_t                dynamicOffsetCount,
-                                  const uint32_t *        pDynamicOffsets ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdBindDescriptorSets(
-        commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets );
-    }
+      VkResult vkCreatePipelineLayout( VkDevice                           device,
+                                       const VkPipelineLayoutCreateInfo * pCreateInfo,
+                                       const VkAllocationCallbacks *      pAllocator,
+                                       VkPipelineLayout *                 pPipelineLayout ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreatePipelineLayout( device, pCreateInfo, pAllocator, pPipelineLayout );
+      }
 
-    void vkCmdBindIndexBuffer( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdBindIndexBuffer( commandBuffer, buffer, offset, indexType );
-    }
+      void vkDestroyPipelineLayout( VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkDestroyPipelineLayout( device, pipelineLayout, pAllocator );
+      }
 
-    void vkCmdBindVertexBuffers( VkCommandBuffer      commandBuffer,
-                                 uint32_t             firstBinding,
-                                 uint32_t             bindingCount,
-                                 const VkBuffer *     pBuffers,
-                                 const VkDeviceSize * pOffsets ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdBindVertexBuffers( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets );
-    }
+      VkResult vkCreateSampler( VkDevice                      device,
+                                const VkSamplerCreateInfo *   pCreateInfo,
+                                const VkAllocationCallbacks * pAllocator,
+                                VkSampler *                   pSampler ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateSampler( device, pCreateInfo, pAllocator, pSampler );
+      }
 
-    void vkCmdDraw( VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance ) const
-      VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdDraw( commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance );
-    }
+      void vkDestroySampler( VkDevice device, VkSampler sampler, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkDestroySampler( device, sampler, pAllocator );
+      }
 
-    void vkCmdDrawIndexed( VkCommandBuffer commandBuffer,
-                           uint32_t        indexCount,
-                           uint32_t        instanceCount,
-                           uint32_t        firstIndex,
-                           int32_t         vertexOffset,
-                           uint32_t        firstInstance ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdDrawIndexed( commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance );
-    }
+      VkResult vkCreateDescriptorSetLayout( VkDevice                                device,
+                                            const VkDescriptorSetLayoutCreateInfo * pCreateInfo,
+                                            const VkAllocationCallbacks *           pAllocator,
+                                            VkDescriptorSetLayout *                 pSetLayout ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateDescriptorSetLayout( device, pCreateInfo, pAllocator, pSetLayout );
+      }
 
-    void vkCmdDrawIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdDrawIndirect( commandBuffer, buffer, offset, drawCount, stride );
-    }
+      void vkDestroyDescriptorSetLayout( VkDevice                      device,
+                                         VkDescriptorSetLayout         descriptorSetLayout,
+                                         const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkDestroyDescriptorSetLayout( device, descriptorSetLayout, pAllocator );
+      }
 
-    void vkCmdDrawIndexedIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride ) const
-      VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdDrawIndexedIndirect( commandBuffer, buffer, offset, drawCount, stride );
-    }
+      VkResult vkCreateDescriptorPool( VkDevice                           device,
+                                       const VkDescriptorPoolCreateInfo * pCreateInfo,
+                                       const VkAllocationCallbacks *      pAllocator,
+                                       VkDescriptorPool *                 pDescriptorPool ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateDescriptorPool( device, pCreateInfo, pAllocator, pDescriptorPool );
+      }
 
-    void vkCmdDispatch( VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdDispatch( commandBuffer, groupCountX, groupCountY, groupCountZ );
-    }
+      void vkDestroyDescriptorPool( VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkDestroyDescriptorPool( device, descriptorPool, pAllocator );
+      }
 
-    void vkCmdDispatchIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdDispatchIndirect( commandBuffer, buffer, offset );
-    }
+      VkResult vkResetDescriptorPool( VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkResetDescriptorPool( device, descriptorPool, flags );
+      }
+
+      VkResult vkAllocateDescriptorSets( VkDevice                            device,
+                                         const VkDescriptorSetAllocateInfo * pAllocateInfo,
+                                         VkDescriptorSet *                   pDescriptorSets ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkAllocateDescriptorSets( device, pAllocateInfo, pDescriptorSets );
+      }
+
+      VkResult vkFreeDescriptorSets( VkDevice                device,
+                                     VkDescriptorPool        descriptorPool,
+                                     uint32_t                descriptorSetCount,
+                                     const VkDescriptorSet * pDescriptorSets ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkFreeDescriptorSets( device, descriptorPool, descriptorSetCount, pDescriptorSets );
+      }
+
+      void vkUpdateDescriptorSets( VkDevice                     device,
+                                   uint32_t                     descriptorWriteCount,
+                                   const VkWriteDescriptorSet * pDescriptorWrites,
+                                   uint32_t                     descriptorCopyCount,
+                                   const VkCopyDescriptorSet *  pDescriptorCopies ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkUpdateDescriptorSets( device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies );
+      }
+
+      VkResult vkCreateFramebuffer( VkDevice                        device,
+                                    const VkFramebufferCreateInfo * pCreateInfo,
+                                    const VkAllocationCallbacks *   pAllocator,
+                                    VkFramebuffer *                 pFramebuffer ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateFramebuffer( device, pCreateInfo, pAllocator, pFramebuffer );
+      }
+
+      void vkDestroyFramebuffer( VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkDestroyFramebuffer( device, framebuffer, pAllocator );
+      }
+
+      VkResult vkCreateRenderPass( VkDevice                       device,
+                                   const VkRenderPassCreateInfo * pCreateInfo,
+                                   const VkAllocationCallbacks *  pAllocator,
+                                   VkRenderPass *                 pRenderPass ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateRenderPass( device, pCreateInfo, pAllocator, pRenderPass );
+      }
+
+      void vkDestroyRenderPass( VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkDestroyRenderPass( device, renderPass, pAllocator );
+      }
+
+      void vkGetRenderAreaGranularity( VkDevice device, VkRenderPass renderPass, VkExtent2D * pGranularity ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetRenderAreaGranularity( device, renderPass, pGranularity );
+      }
+
+      VkResult vkCreateCommandPool( VkDevice                        device,
+                                    const VkCommandPoolCreateInfo * pCreateInfo,
+                                    const VkAllocationCallbacks *   pAllocator,
+                                    VkCommandPool *                 pCommandPool ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateCommandPool( device, pCreateInfo, pAllocator, pCommandPool );
+      }
+
+      void vkDestroyCommandPool( VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkDestroyCommandPool( device, commandPool, pAllocator );
+      }
+
+      VkResult vkResetCommandPool( VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkResetCommandPool( device, commandPool, flags );
+      }
+
+      VkResult vkAllocateCommandBuffers( VkDevice                            device,
+                                         const VkCommandBufferAllocateInfo * pAllocateInfo,
+                                         VkCommandBuffer *                   pCommandBuffers ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkAllocateCommandBuffers( device, pAllocateInfo, pCommandBuffers );
+      }
+
+      void vkFreeCommandBuffers( VkDevice                device,
+                                 VkCommandPool           commandPool,
+                                 uint32_t                commandBufferCount,
+                                 const VkCommandBuffer * pCommandBuffers ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkFreeCommandBuffers( device, commandPool, commandBufferCount, pCommandBuffers );
+      }
+
+      VkResult vkBeginCommandBuffer( VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo * pBeginInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkBeginCommandBuffer( commandBuffer, pBeginInfo );
+      }
+
+      VkResult vkEndCommandBuffer( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkEndCommandBuffer( commandBuffer );
+      }
+
+      VkResult vkResetCommandBuffer( VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkResetCommandBuffer( commandBuffer, flags );
+      }
+
+      void vkCmdBindPipeline( VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdBindPipeline( commandBuffer, pipelineBindPoint, pipeline );
+      }
+
+      void vkCmdSetViewport( VkCommandBuffer    commandBuffer,
+                             uint32_t           firstViewport,
+                             uint32_t           viewportCount,
+                             const VkViewport * pViewports ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetViewport( commandBuffer, firstViewport, viewportCount, pViewports );
+      }
+
+      void vkCmdSetScissor( VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D * pScissors ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetScissor( commandBuffer, firstScissor, scissorCount, pScissors );
+      }
+
+      void vkCmdSetLineWidth( VkCommandBuffer commandBuffer, float lineWidth ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetLineWidth( commandBuffer, lineWidth );
+      }
+
+      void vkCmdSetDepthBias( VkCommandBuffer commandBuffer,
+                              float           depthBiasConstantFactor,
+                              float           depthBiasClamp,
+                              float           depthBiasSlopeFactor ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetDepthBias( commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor );
+      }
+
+      void vkCmdSetBlendConstants( VkCommandBuffer commandBuffer, const float blendConstants[4] ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetBlendConstants( commandBuffer, blendConstants );
+      }
+
+      void vkCmdSetDepthBounds( VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetDepthBounds( commandBuffer, minDepthBounds, maxDepthBounds );
+      }
+
+      void vkCmdSetStencilCompareMask( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetStencilCompareMask( commandBuffer, faceMask, compareMask );
+      }
+
+      void vkCmdSetStencilWriteMask( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetStencilWriteMask( commandBuffer, faceMask, writeMask );
+      }
+
+      void vkCmdSetStencilReference( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetStencilReference( commandBuffer, faceMask, reference );
+      }
+
+      void vkCmdBindDescriptorSets( VkCommandBuffer         commandBuffer,
+                                    VkPipelineBindPoint     pipelineBindPoint,
+                                    VkPipelineLayout        layout,
+                                    uint32_t                firstSet,
+                                    uint32_t                descriptorSetCount,
+                                    const VkDescriptorSet * pDescriptorSets,
+                                    uint32_t                dynamicOffsetCount,
+                                    const uint32_t *        pDynamicOffsets ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdBindDescriptorSets(
+          commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets );
+      }
+
+      void vkCmdBindIndexBuffer( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdBindIndexBuffer( commandBuffer, buffer, offset, indexType );
+      }
+
+      void vkCmdBindVertexBuffers( VkCommandBuffer      commandBuffer,
+                                   uint32_t             firstBinding,
+                                   uint32_t             bindingCount,
+                                   const VkBuffer *     pBuffers,
+                                   const VkDeviceSize * pOffsets ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdBindVertexBuffers( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets );
+      }
+
+      void vkCmdDraw( VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance ) const
+        VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdDraw( commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance );
+      }
+
+      void vkCmdDrawIndexed( VkCommandBuffer commandBuffer,
+                             uint32_t        indexCount,
+                             uint32_t        instanceCount,
+                             uint32_t        firstIndex,
+                             int32_t         vertexOffset,
+                             uint32_t        firstInstance ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdDrawIndexed( commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance );
+      }
+
+      void
+        vkCmdDrawIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdDrawIndirect( commandBuffer, buffer, offset, drawCount, stride );
+      }
+
+      void vkCmdDrawIndexedIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride ) const
+        VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdDrawIndexedIndirect( commandBuffer, buffer, offset, drawCount, stride );
+      }
 
-    void vkCmdCopyBuffer( VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy * pRegions ) const
-      VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdCopyBuffer( commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions );
-    }
+      void vkCmdDispatch( VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdDispatch( commandBuffer, groupCountX, groupCountY, groupCountZ );
+      }
 
-    void vkCmdCopyImage( VkCommandBuffer     commandBuffer,
-                         VkImage             srcImage,
-                         VkImageLayout       srcImageLayout,
-                         VkImage             dstImage,
-                         VkImageLayout       dstImageLayout,
-                         uint32_t            regionCount,
-                         const VkImageCopy * pRegions ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdCopyImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions );
-    }
+      void vkCmdDispatchIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdDispatchIndirect( commandBuffer, buffer, offset );
+      }
 
-    void vkCmdBlitImage( VkCommandBuffer     commandBuffer,
-                         VkImage             srcImage,
-                         VkImageLayout       srcImageLayout,
-                         VkImage             dstImage,
-                         VkImageLayout       dstImageLayout,
-                         uint32_t            regionCount,
-                         const VkImageBlit * pRegions,
-                         VkFilter            filter ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdBlitImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter );
-    }
+      void vkCmdCopyBuffer( VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy * pRegions ) const
+        VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdCopyBuffer( commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions );
+      }
 
-    void vkCmdCopyBufferToImage( VkCommandBuffer           commandBuffer,
-                                 VkBuffer                  srcBuffer,
-                                 VkImage                   dstImage,
-                                 VkImageLayout             dstImageLayout,
-                                 uint32_t                  regionCount,
-                                 const VkBufferImageCopy * pRegions ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdCopyBufferToImage( commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions );
-    }
+      void vkCmdCopyImage( VkCommandBuffer     commandBuffer,
+                           VkImage             srcImage,
+                           VkImageLayout       srcImageLayout,
+                           VkImage             dstImage,
+                           VkImageLayout       dstImageLayout,
+                           uint32_t            regionCount,
+                           const VkImageCopy * pRegions ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdCopyImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions );
+      }
 
-    void vkCmdCopyImageToBuffer( VkCommandBuffer           commandBuffer,
-                                 VkImage                   srcImage,
-                                 VkImageLayout             srcImageLayout,
-                                 VkBuffer                  dstBuffer,
-                                 uint32_t                  regionCount,
-                                 const VkBufferImageCopy * pRegions ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdCopyImageToBuffer( commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions );
-    }
+      void vkCmdBlitImage( VkCommandBuffer     commandBuffer,
+                           VkImage             srcImage,
+                           VkImageLayout       srcImageLayout,
+                           VkImage             dstImage,
+                           VkImageLayout       dstImageLayout,
+                           uint32_t            regionCount,
+                           const VkImageBlit * pRegions,
+                           VkFilter            filter ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdBlitImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter );
+      }
 
-    void vkCmdUpdateBuffer( VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void * pData ) const
-      VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdUpdateBuffer( commandBuffer, dstBuffer, dstOffset, dataSize, pData );
-    }
+      void vkCmdCopyBufferToImage( VkCommandBuffer           commandBuffer,
+                                   VkBuffer                  srcBuffer,
+                                   VkImage                   dstImage,
+                                   VkImageLayout             dstImageLayout,
+                                   uint32_t                  regionCount,
+                                   const VkBufferImageCopy * pRegions ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdCopyBufferToImage( commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions );
+      }
 
-    void
-      vkCmdFillBuffer( VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdFillBuffer( commandBuffer, dstBuffer, dstOffset, size, data );
-    }
+      void vkCmdCopyImageToBuffer( VkCommandBuffer           commandBuffer,
+                                   VkImage                   srcImage,
+                                   VkImageLayout             srcImageLayout,
+                                   VkBuffer                  dstBuffer,
+                                   uint32_t                  regionCount,
+                                   const VkBufferImageCopy * pRegions ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdCopyImageToBuffer( commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions );
+      }
 
-    void vkCmdClearColorImage( VkCommandBuffer                 commandBuffer,
-                               VkImage                         image,
-                               VkImageLayout                   imageLayout,
-                               const VkClearColorValue *       pColor,
-                               uint32_t                        rangeCount,
-                               const VkImageSubresourceRange * pRanges ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdClearColorImage( commandBuffer, image, imageLayout, pColor, rangeCount, pRanges );
-    }
+      void vkCmdUpdateBuffer( VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void * pData ) const
+        VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdUpdateBuffer( commandBuffer, dstBuffer, dstOffset, dataSize, pData );
+      }
 
-    void vkCmdClearDepthStencilImage( VkCommandBuffer                  commandBuffer,
-                                      VkImage                          image,
-                                      VkImageLayout                    imageLayout,
-                                      const VkClearDepthStencilValue * pDepthStencil,
-                                      uint32_t                         rangeCount,
-                                      const VkImageSubresourceRange *  pRanges ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdClearDepthStencilImage( commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges );
-    }
+      void
+        vkCmdFillBuffer( VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdFillBuffer( commandBuffer, dstBuffer, dstOffset, size, data );
+      }
 
-    void vkCmdClearAttachments( VkCommandBuffer           commandBuffer,
-                                uint32_t                  attachmentCount,
-                                const VkClearAttachment * pAttachments,
-                                uint32_t                  rectCount,
-                                const VkClearRect *       pRects ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdClearAttachments( commandBuffer, attachmentCount, pAttachments, rectCount, pRects );
-    }
+      void vkCmdClearColorImage( VkCommandBuffer                 commandBuffer,
+                                 VkImage                         image,
+                                 VkImageLayout                   imageLayout,
+                                 const VkClearColorValue *       pColor,
+                                 uint32_t                        rangeCount,
+                                 const VkImageSubresourceRange * pRanges ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdClearColorImage( commandBuffer, image, imageLayout, pColor, rangeCount, pRanges );
+      }
 
-    void vkCmdResolveImage( VkCommandBuffer        commandBuffer,
-                            VkImage                srcImage,
-                            VkImageLayout          srcImageLayout,
-                            VkImage                dstImage,
-                            VkImageLayout          dstImageLayout,
-                            uint32_t               regionCount,
-                            const VkImageResolve * pRegions ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdResolveImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions );
-    }
+      void vkCmdClearDepthStencilImage( VkCommandBuffer                  commandBuffer,
+                                        VkImage                          image,
+                                        VkImageLayout                    imageLayout,
+                                        const VkClearDepthStencilValue * pDepthStencil,
+                                        uint32_t                         rangeCount,
+                                        const VkImageSubresourceRange *  pRanges ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdClearDepthStencilImage( commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges );
+      }
 
-    void vkCmdSetEvent( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetEvent( commandBuffer, event, stageMask );
-    }
+      void vkCmdClearAttachments( VkCommandBuffer           commandBuffer,
+                                  uint32_t                  attachmentCount,
+                                  const VkClearAttachment * pAttachments,
+                                  uint32_t                  rectCount,
+                                  const VkClearRect *       pRects ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdClearAttachments( commandBuffer, attachmentCount, pAttachments, rectCount, pRects );
+      }
 
-    void vkCmdResetEvent( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdResetEvent( commandBuffer, event, stageMask );
-    }
+      void vkCmdResolveImage( VkCommandBuffer        commandBuffer,
+                              VkImage                srcImage,
+                              VkImageLayout          srcImageLayout,
+                              VkImage                dstImage,
+                              VkImageLayout          dstImageLayout,
+                              uint32_t               regionCount,
+                              const VkImageResolve * pRegions ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdResolveImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions );
+      }
 
-    void vkCmdWaitEvents( VkCommandBuffer               commandBuffer,
-                          uint32_t                      eventCount,
-                          const VkEvent *               pEvents,
-                          VkPipelineStageFlags          srcStageMask,
-                          VkPipelineStageFlags          dstStageMask,
-                          uint32_t                      memoryBarrierCount,
-                          const VkMemoryBarrier *       pMemoryBarriers,
-                          uint32_t                      bufferMemoryBarrierCount,
-                          const VkBufferMemoryBarrier * pBufferMemoryBarriers,
-                          uint32_t                      imageMemoryBarrierCount,
-                          const VkImageMemoryBarrier *  pImageMemoryBarriers ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdWaitEvents( commandBuffer,
-                                eventCount,
-                                pEvents,
-                                srcStageMask,
-                                dstStageMask,
-                                memoryBarrierCount,
-                                pMemoryBarriers,
-                                bufferMemoryBarrierCount,
-                                pBufferMemoryBarriers,
-                                imageMemoryBarrierCount,
-                                pImageMemoryBarriers );
-    }
+      void vkCmdSetEvent( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetEvent( commandBuffer, event, stageMask );
+      }
 
-    void vkCmdPipelineBarrier( VkCommandBuffer               commandBuffer,
-                               VkPipelineStageFlags          srcStageMask,
-                               VkPipelineStageFlags          dstStageMask,
-                               VkDependencyFlags             dependencyFlags,
-                               uint32_t                      memoryBarrierCount,
-                               const VkMemoryBarrier *       pMemoryBarriers,
-                               uint32_t                      bufferMemoryBarrierCount,
-                               const VkBufferMemoryBarrier * pBufferMemoryBarriers,
-                               uint32_t                      imageMemoryBarrierCount,
-                               const VkImageMemoryBarrier *  pImageMemoryBarriers ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdPipelineBarrier( commandBuffer,
-                                     srcStageMask,
-                                     dstStageMask,
-                                     dependencyFlags,
-                                     memoryBarrierCount,
-                                     pMemoryBarriers,
-                                     bufferMemoryBarrierCount,
-                                     pBufferMemoryBarriers,
-                                     imageMemoryBarrierCount,
-                                     pImageMemoryBarriers );
-    }
+      void vkCmdResetEvent( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdResetEvent( commandBuffer, event, stageMask );
+      }
 
-    void vkCmdBeginQuery( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdBeginQuery( commandBuffer, queryPool, query, flags );
-    }
+      void vkCmdWaitEvents( VkCommandBuffer               commandBuffer,
+                            uint32_t                      eventCount,
+                            const VkEvent *               pEvents,
+                            VkPipelineStageFlags          srcStageMask,
+                            VkPipelineStageFlags          dstStageMask,
+                            uint32_t                      memoryBarrierCount,
+                            const VkMemoryBarrier *       pMemoryBarriers,
+                            uint32_t                      bufferMemoryBarrierCount,
+                            const VkBufferMemoryBarrier * pBufferMemoryBarriers,
+                            uint32_t                      imageMemoryBarrierCount,
+                            const VkImageMemoryBarrier *  pImageMemoryBarriers ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdWaitEvents( commandBuffer,
+                                  eventCount,
+                                  pEvents,
+                                  srcStageMask,
+                                  dstStageMask,
+                                  memoryBarrierCount,
+                                  pMemoryBarriers,
+                                  bufferMemoryBarrierCount,
+                                  pBufferMemoryBarriers,
+                                  imageMemoryBarrierCount,
+                                  pImageMemoryBarriers );
+      }
 
-    void vkCmdEndQuery( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdEndQuery( commandBuffer, queryPool, query );
-    }
+      void vkCmdPipelineBarrier( VkCommandBuffer               commandBuffer,
+                                 VkPipelineStageFlags          srcStageMask,
+                                 VkPipelineStageFlags          dstStageMask,
+                                 VkDependencyFlags             dependencyFlags,
+                                 uint32_t                      memoryBarrierCount,
+                                 const VkMemoryBarrier *       pMemoryBarriers,
+                                 uint32_t                      bufferMemoryBarrierCount,
+                                 const VkBufferMemoryBarrier * pBufferMemoryBarriers,
+                                 uint32_t                      imageMemoryBarrierCount,
+                                 const VkImageMemoryBarrier *  pImageMemoryBarriers ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdPipelineBarrier( commandBuffer,
+                                       srcStageMask,
+                                       dstStageMask,
+                                       dependencyFlags,
+                                       memoryBarrierCount,
+                                       pMemoryBarriers,
+                                       bufferMemoryBarrierCount,
+                                       pBufferMemoryBarriers,
+                                       imageMemoryBarrierCount,
+                                       pImageMemoryBarriers );
+      }
 
-    void vkCmdResetQueryPool( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdResetQueryPool( commandBuffer, queryPool, firstQuery, queryCount );
-    }
+      void vkCmdBeginQuery( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdBeginQuery( commandBuffer, queryPool, query, flags );
+      }
 
-    void vkCmdWriteTimestamp( VkCommandBuffer         commandBuffer,
-                              VkPipelineStageFlagBits pipelineStage,
-                              VkQueryPool             queryPool,
-                              uint32_t                query ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdWriteTimestamp( commandBuffer, pipelineStage, queryPool, query );
-    }
+      void vkCmdEndQuery( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdEndQuery( commandBuffer, queryPool, query );
+      }
 
-    void vkCmdCopyQueryPoolResults( VkCommandBuffer    commandBuffer,
-                                    VkQueryPool        queryPool,
-                                    uint32_t           firstQuery,
-                                    uint32_t           queryCount,
-                                    VkBuffer           dstBuffer,
-                                    VkDeviceSize       dstOffset,
-                                    VkDeviceSize       stride,
-                                    VkQueryResultFlags flags ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdCopyQueryPoolResults( commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags );
-    }
+      void vkCmdResetQueryPool( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdResetQueryPool( commandBuffer, queryPool, firstQuery, queryCount );
+      }
 
-    void vkCmdPushConstants( VkCommandBuffer    commandBuffer,
-                             VkPipelineLayout   layout,
-                             VkShaderStageFlags stageFlags,
-                             uint32_t           offset,
-                             uint32_t           size,
-                             const void *       pValues ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdPushConstants( commandBuffer, layout, stageFlags, offset, size, pValues );
-    }
+      void vkCmdWriteTimestamp( VkCommandBuffer         commandBuffer,
+                                VkPipelineStageFlagBits pipelineStage,
+                                VkQueryPool             queryPool,
+                                uint32_t                query ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdWriteTimestamp( commandBuffer, pipelineStage, queryPool, query );
+      }
 
-    void vkCmdBeginRenderPass( VkCommandBuffer               commandBuffer,
-                               const VkRenderPassBeginInfo * pRenderPassBegin,
-                               VkSubpassContents             contents ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdBeginRenderPass( commandBuffer, pRenderPassBegin, contents );
-    }
+      void vkCmdCopyQueryPoolResults( VkCommandBuffer    commandBuffer,
+                                      VkQueryPool        queryPool,
+                                      uint32_t           firstQuery,
+                                      uint32_t           queryCount,
+                                      VkBuffer           dstBuffer,
+                                      VkDeviceSize       dstOffset,
+                                      VkDeviceSize       stride,
+                                      VkQueryResultFlags flags ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdCopyQueryPoolResults( commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags );
+      }
 
-    void vkCmdNextSubpass( VkCommandBuffer commandBuffer, VkSubpassContents contents ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdNextSubpass( commandBuffer, contents );
-    }
+      void vkCmdPushConstants( VkCommandBuffer    commandBuffer,
+                               VkPipelineLayout   layout,
+                               VkShaderStageFlags stageFlags,
+                               uint32_t           offset,
+                               uint32_t           size,
+                               const void *       pValues ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdPushConstants( commandBuffer, layout, stageFlags, offset, size, pValues );
+      }
 
-    void vkCmdEndRenderPass( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdEndRenderPass( commandBuffer );
-    }
+      void vkCmdBeginRenderPass( VkCommandBuffer               commandBuffer,
+                                 const VkRenderPassBeginInfo * pRenderPassBegin,
+                                 VkSubpassContents             contents ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdBeginRenderPass( commandBuffer, pRenderPassBegin, contents );
+      }
 
-    void vkCmdExecuteCommands( VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer * pCommandBuffers ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdExecuteCommands( commandBuffer, commandBufferCount, pCommandBuffers );
-    }
+      void vkCmdNextSubpass( VkCommandBuffer commandBuffer, VkSubpassContents contents ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdNextSubpass( commandBuffer, contents );
+      }
 
-    //=== VK_VERSION_1_1 ===
+      void vkCmdEndRenderPass( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdEndRenderPass( commandBuffer );
+      }
 
-    VkResult vkEnumerateInstanceVersion( uint32_t * pApiVersion ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkEnumerateInstanceVersion( pApiVersion );
-    }
+      void vkCmdExecuteCommands( VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer * pCommandBuffers ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdExecuteCommands( commandBuffer, commandBufferCount, pCommandBuffers );
+      }
 
-    VkResult vkBindBufferMemory2( VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo * pBindInfos ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkBindBufferMemory2( device, bindInfoCount, pBindInfos );
-    }
+      //=== VK_VERSION_1_1 ===
 
-    VkResult vkBindImageMemory2( VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo * pBindInfos ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkBindImageMemory2( device, bindInfoCount, pBindInfos );
-    }
+      VkResult vkEnumerateInstanceVersion( uint32_t * pApiVersion ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkEnumerateInstanceVersion( pApiVersion );
+      }
 
-    void vkGetDeviceGroupPeerMemoryFeatures( VkDevice                   device,
-                                             uint32_t                   heapIndex,
-                                             uint32_t                   localDeviceIndex,
-                                             uint32_t                   remoteDeviceIndex,
-                                             VkPeerMemoryFeatureFlags * pPeerMemoryFeatures ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetDeviceGroupPeerMemoryFeatures( device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures );
-    }
+      VkResult vkBindBufferMemory2( VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo * pBindInfos ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkBindBufferMemory2( device, bindInfoCount, pBindInfos );
+      }
 
-    void vkCmdSetDeviceMask( VkCommandBuffer commandBuffer, uint32_t deviceMask ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetDeviceMask( commandBuffer, deviceMask );
-    }
+      VkResult vkBindImageMemory2( VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo * pBindInfos ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkBindImageMemory2( device, bindInfoCount, pBindInfos );
+      }
 
-    void vkCmdDispatchBase( VkCommandBuffer commandBuffer,
-                            uint32_t        baseGroupX,
-                            uint32_t        baseGroupY,
-                            uint32_t        baseGroupZ,
-                            uint32_t        groupCountX,
-                            uint32_t        groupCountY,
-                            uint32_t        groupCountZ ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdDispatchBase( commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ );
-    }
+      void vkGetDeviceGroupPeerMemoryFeatures( VkDevice                   device,
+                                               uint32_t                   heapIndex,
+                                               uint32_t                   localDeviceIndex,
+                                               uint32_t                   remoteDeviceIndex,
+                                               VkPeerMemoryFeatureFlags * pPeerMemoryFeatures ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetDeviceGroupPeerMemoryFeatures( device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures );
+      }
 
-    VkResult vkEnumeratePhysicalDeviceGroups( VkInstance                        instance,
-                                              uint32_t *                        pPhysicalDeviceGroupCount,
-                                              VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkEnumeratePhysicalDeviceGroups( instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties );
-    }
+      void vkCmdSetDeviceMask( VkCommandBuffer commandBuffer, uint32_t deviceMask ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetDeviceMask( commandBuffer, deviceMask );
+      }
 
-    void vkGetImageMemoryRequirements2( VkDevice                               device,
-                                        const VkImageMemoryRequirementsInfo2 * pInfo,
-                                        VkMemoryRequirements2 *                pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetImageMemoryRequirements2( device, pInfo, pMemoryRequirements );
-    }
+      void vkCmdDispatchBase( VkCommandBuffer commandBuffer,
+                              uint32_t        baseGroupX,
+                              uint32_t        baseGroupY,
+                              uint32_t        baseGroupZ,
+                              uint32_t        groupCountX,
+                              uint32_t        groupCountY,
+                              uint32_t        groupCountZ ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdDispatchBase( commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ );
+      }
 
-    void vkGetBufferMemoryRequirements2( VkDevice                                device,
-                                         const VkBufferMemoryRequirementsInfo2 * pInfo,
-                                         VkMemoryRequirements2 *                 pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetBufferMemoryRequirements2( device, pInfo, pMemoryRequirements );
-    }
+      VkResult vkEnumeratePhysicalDeviceGroups( VkInstance                        instance,
+                                                uint32_t *                        pPhysicalDeviceGroupCount,
+                                                VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkEnumeratePhysicalDeviceGroups( instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties );
+      }
 
-    void vkGetImageSparseMemoryRequirements2( VkDevice                                     device,
-                                              const VkImageSparseMemoryRequirementsInfo2 * pInfo,
-                                              uint32_t *                                   pSparseMemoryRequirementCount,
-                                              VkSparseImageMemoryRequirements2 *           pSparseMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetImageSparseMemoryRequirements2( device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements );
-    }
+      void vkGetImageMemoryRequirements2( VkDevice                               device,
+                                          const VkImageMemoryRequirementsInfo2 * pInfo,
+                                          VkMemoryRequirements2 *                pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetImageMemoryRequirements2( device, pInfo, pMemoryRequirements );
+      }
 
-    void vkGetPhysicalDeviceFeatures2( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 * pFeatures ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceFeatures2( physicalDevice, pFeatures );
-    }
+      void vkGetBufferMemoryRequirements2( VkDevice                                device,
+                                           const VkBufferMemoryRequirementsInfo2 * pInfo,
+                                           VkMemoryRequirements2 *                 pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetBufferMemoryRequirements2( device, pInfo, pMemoryRequirements );
+      }
 
-    void vkGetPhysicalDeviceProperties2( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 * pProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceProperties2( physicalDevice, pProperties );
-    }
+      void vkGetImageSparseMemoryRequirements2( VkDevice                                     device,
+                                                const VkImageSparseMemoryRequirementsInfo2 * pInfo,
+                                                uint32_t *                                   pSparseMemoryRequirementCount,
+                                                VkSparseImageMemoryRequirements2 *           pSparseMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetImageSparseMemoryRequirements2( device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements );
+      }
 
-    void vkGetPhysicalDeviceFormatProperties2( VkPhysicalDevice      physicalDevice,
-                                               VkFormat              format,
-                                               VkFormatProperties2 * pFormatProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceFormatProperties2( physicalDevice, format, pFormatProperties );
-    }
+      void vkGetPhysicalDeviceFeatures2( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 * pFeatures ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceFeatures2( physicalDevice, pFeatures );
+      }
 
-    VkResult vkGetPhysicalDeviceImageFormatProperties2( VkPhysicalDevice                         physicalDevice,
-                                                        const VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo,
-                                                        VkImageFormatProperties2 *               pImageFormatProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceImageFormatProperties2( physicalDevice, pImageFormatInfo, pImageFormatProperties );
-    }
+      void vkGetPhysicalDeviceProperties2( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 * pProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceProperties2( physicalDevice, pProperties );
+      }
 
-    void vkGetPhysicalDeviceQueueFamilyProperties2( VkPhysicalDevice           physicalDevice,
-                                                    uint32_t *                 pQueueFamilyPropertyCount,
-                                                    VkQueueFamilyProperties2 * pQueueFamilyProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceQueueFamilyProperties2( physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties );
-    }
+      void vkGetPhysicalDeviceFormatProperties2( VkPhysicalDevice      physicalDevice,
+                                                 VkFormat              format,
+                                                 VkFormatProperties2 * pFormatProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceFormatProperties2( physicalDevice, format, pFormatProperties );
+      }
 
-    void vkGetPhysicalDeviceMemoryProperties2( VkPhysicalDevice                    physicalDevice,
-                                               VkPhysicalDeviceMemoryProperties2 * pMemoryProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceMemoryProperties2( physicalDevice, pMemoryProperties );
-    }
+      VkResult vkGetPhysicalDeviceImageFormatProperties2( VkPhysicalDevice                         physicalDevice,
+                                                          const VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo,
+                                                          VkImageFormatProperties2 *               pImageFormatProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceImageFormatProperties2( physicalDevice, pImageFormatInfo, pImageFormatProperties );
+      }
 
-    void vkGetPhysicalDeviceSparseImageFormatProperties2( VkPhysicalDevice                               physicalDevice,
-                                                          const VkPhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,
-                                                          uint32_t *                                     pPropertyCount,
-                                                          VkSparseImageFormatProperties2 *               pProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceSparseImageFormatProperties2( physicalDevice, pFormatInfo, pPropertyCount, pProperties );
-    }
+      void vkGetPhysicalDeviceQueueFamilyProperties2( VkPhysicalDevice           physicalDevice,
+                                                      uint32_t *                 pQueueFamilyPropertyCount,
+                                                      VkQueueFamilyProperties2 * pQueueFamilyProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceQueueFamilyProperties2( physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties );
+      }
 
-    void vkTrimCommandPool( VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkTrimCommandPool( device, commandPool, flags );
-    }
+      void vkGetPhysicalDeviceMemoryProperties2( VkPhysicalDevice                    physicalDevice,
+                                                 VkPhysicalDeviceMemoryProperties2 * pMemoryProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceMemoryProperties2( physicalDevice, pMemoryProperties );
+      }
 
-    void vkGetDeviceQueue2( VkDevice device, const VkDeviceQueueInfo2 * pQueueInfo, VkQueue * pQueue ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetDeviceQueue2( device, pQueueInfo, pQueue );
-    }
+      void vkGetPhysicalDeviceSparseImageFormatProperties2( VkPhysicalDevice                               physicalDevice,
+                                                            const VkPhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,
+                                                            uint32_t *                                     pPropertyCount,
+                                                            VkSparseImageFormatProperties2 *               pProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceSparseImageFormatProperties2( physicalDevice, pFormatInfo, pPropertyCount, pProperties );
+      }
 
-    VkResult vkCreateSamplerYcbcrConversion( VkDevice                                   device,
-                                             const VkSamplerYcbcrConversionCreateInfo * pCreateInfo,
-                                             const VkAllocationCallbacks *              pAllocator,
-                                             VkSamplerYcbcrConversion *                 pYcbcrConversion ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateSamplerYcbcrConversion( device, pCreateInfo, pAllocator, pYcbcrConversion );
-    }
+      void vkTrimCommandPool( VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkTrimCommandPool( device, commandPool, flags );
+      }
 
-    void vkDestroySamplerYcbcrConversion( VkDevice                      device,
-                                          VkSamplerYcbcrConversion      ycbcrConversion,
-                                          const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkDestroySamplerYcbcrConversion( device, ycbcrConversion, pAllocator );
-    }
+      void vkGetDeviceQueue2( VkDevice device, const VkDeviceQueueInfo2 * pQueueInfo, VkQueue * pQueue ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetDeviceQueue2( device, pQueueInfo, pQueue );
+      }
 
-    VkResult vkCreateDescriptorUpdateTemplate( VkDevice                                     device,
-                                               const VkDescriptorUpdateTemplateCreateInfo * pCreateInfo,
-                                               const VkAllocationCallbacks *                pAllocator,
-                                               VkDescriptorUpdateTemplate *                 pDescriptorUpdateTemplate ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateDescriptorUpdateTemplate( device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate );
-    }
+      VkResult vkCreateSamplerYcbcrConversion( VkDevice                                   device,
+                                               const VkSamplerYcbcrConversionCreateInfo * pCreateInfo,
+                                               const VkAllocationCallbacks *              pAllocator,
+                                               VkSamplerYcbcrConversion *                 pYcbcrConversion ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateSamplerYcbcrConversion( device, pCreateInfo, pAllocator, pYcbcrConversion );
+      }
 
-    void vkDestroyDescriptorUpdateTemplate( VkDevice                      device,
-                                            VkDescriptorUpdateTemplate    descriptorUpdateTemplate,
+      void vkDestroySamplerYcbcrConversion( VkDevice                      device,
+                                            VkSamplerYcbcrConversion      ycbcrConversion,
                                             const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkDestroyDescriptorUpdateTemplate( device, descriptorUpdateTemplate, pAllocator );
-    }
+      {
+        return ::vkDestroySamplerYcbcrConversion( device, ycbcrConversion, pAllocator );
+      }
 
-    void vkUpdateDescriptorSetWithTemplate( VkDevice                   device,
-                                            VkDescriptorSet            descriptorSet,
-                                            VkDescriptorUpdateTemplate descriptorUpdateTemplate,
-                                            const void *               pData ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkUpdateDescriptorSetWithTemplate( device, descriptorSet, descriptorUpdateTemplate, pData );
-    }
+      VkResult vkCreateDescriptorUpdateTemplate( VkDevice                                     device,
+                                                 const VkDescriptorUpdateTemplateCreateInfo * pCreateInfo,
+                                                 const VkAllocationCallbacks *                pAllocator,
+                                                 VkDescriptorUpdateTemplate *                 pDescriptorUpdateTemplate ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateDescriptorUpdateTemplate( device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate );
+      }
 
-    void vkGetPhysicalDeviceExternalBufferProperties( VkPhysicalDevice                           physicalDevice,
-                                                      const VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo,
-                                                      VkExternalBufferProperties *               pExternalBufferProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceExternalBufferProperties( physicalDevice, pExternalBufferInfo, pExternalBufferProperties );
-    }
+      void vkDestroyDescriptorUpdateTemplate( VkDevice                      device,
+                                              VkDescriptorUpdateTemplate    descriptorUpdateTemplate,
+                                              const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkDestroyDescriptorUpdateTemplate( device, descriptorUpdateTemplate, pAllocator );
+      }
 
-    void vkGetPhysicalDeviceExternalFenceProperties( VkPhysicalDevice                          physicalDevice,
-                                                     const VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo,
-                                                     VkExternalFenceProperties *               pExternalFenceProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceExternalFenceProperties( physicalDevice, pExternalFenceInfo, pExternalFenceProperties );
-    }
+      void vkUpdateDescriptorSetWithTemplate( VkDevice                   device,
+                                              VkDescriptorSet            descriptorSet,
+                                              VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+                                              const void *               pData ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkUpdateDescriptorSetWithTemplate( device, descriptorSet, descriptorUpdateTemplate, pData );
+      }
 
-    void vkGetPhysicalDeviceExternalSemaphoreProperties( VkPhysicalDevice                              physicalDevice,
-                                                         const VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,
-                                                         VkExternalSemaphoreProperties *               pExternalSemaphoreProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceExternalSemaphoreProperties( physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties );
-    }
+      void vkGetPhysicalDeviceExternalBufferProperties( VkPhysicalDevice                           physicalDevice,
+                                                        const VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo,
+                                                        VkExternalBufferProperties *               pExternalBufferProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceExternalBufferProperties( physicalDevice, pExternalBufferInfo, pExternalBufferProperties );
+      }
 
-    void vkGetDescriptorSetLayoutSupport( VkDevice                                device,
-                                          const VkDescriptorSetLayoutCreateInfo * pCreateInfo,
-                                          VkDescriptorSetLayoutSupport *          pSupport ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetDescriptorSetLayoutSupport( device, pCreateInfo, pSupport );
-    }
+      void vkGetPhysicalDeviceExternalFenceProperties( VkPhysicalDevice                          physicalDevice,
+                                                       const VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo,
+                                                       VkExternalFenceProperties *               pExternalFenceProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceExternalFenceProperties( physicalDevice, pExternalFenceInfo, pExternalFenceProperties );
+      }
 
-    //=== VK_VERSION_1_2 ===
+      void vkGetPhysicalDeviceExternalSemaphoreProperties( VkPhysicalDevice                              physicalDevice,
+                                                           const VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,
+                                                           VkExternalSemaphoreProperties * pExternalSemaphoreProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceExternalSemaphoreProperties( physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties );
+      }
 
-    void vkCmdDrawIndirectCount( VkCommandBuffer commandBuffer,
-                                 VkBuffer        buffer,
-                                 VkDeviceSize    offset,
-                                 VkBuffer        countBuffer,
-                                 VkDeviceSize    countBufferOffset,
-                                 uint32_t        maxDrawCount,
-                                 uint32_t        stride ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdDrawIndirectCount( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
-    }
+      void vkGetDescriptorSetLayoutSupport( VkDevice                                device,
+                                            const VkDescriptorSetLayoutCreateInfo * pCreateInfo,
+                                            VkDescriptorSetLayoutSupport *          pSupport ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetDescriptorSetLayoutSupport( device, pCreateInfo, pSupport );
+      }
 
-    void vkCmdDrawIndexedIndirectCount( VkCommandBuffer commandBuffer,
-                                        VkBuffer        buffer,
-                                        VkDeviceSize    offset,
-                                        VkBuffer        countBuffer,
-                                        VkDeviceSize    countBufferOffset,
-                                        uint32_t        maxDrawCount,
-                                        uint32_t        stride ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdDrawIndexedIndirectCount( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
-    }
+      //=== VK_VERSION_1_2 ===
 
-    VkResult vkCreateRenderPass2( VkDevice                        device,
-                                  const VkRenderPassCreateInfo2 * pCreateInfo,
-                                  const VkAllocationCallbacks *   pAllocator,
-                                  VkRenderPass *                  pRenderPass ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateRenderPass2( device, pCreateInfo, pAllocator, pRenderPass );
-    }
+      void vkCmdDrawIndirectCount( VkCommandBuffer commandBuffer,
+                                   VkBuffer        buffer,
+                                   VkDeviceSize    offset,
+                                   VkBuffer        countBuffer,
+                                   VkDeviceSize    countBufferOffset,
+                                   uint32_t        maxDrawCount,
+                                   uint32_t        stride ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdDrawIndirectCount( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
+      }
 
-    void vkCmdBeginRenderPass2( VkCommandBuffer               commandBuffer,
-                                const VkRenderPassBeginInfo * pRenderPassBegin,
-                                const VkSubpassBeginInfo *    pSubpassBeginInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdBeginRenderPass2( commandBuffer, pRenderPassBegin, pSubpassBeginInfo );
-    }
+      void vkCmdDrawIndexedIndirectCount( VkCommandBuffer commandBuffer,
+                                          VkBuffer        buffer,
+                                          VkDeviceSize    offset,
+                                          VkBuffer        countBuffer,
+                                          VkDeviceSize    countBufferOffset,
+                                          uint32_t        maxDrawCount,
+                                          uint32_t        stride ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdDrawIndexedIndirectCount( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
+      }
 
-    void vkCmdNextSubpass2( VkCommandBuffer            commandBuffer,
-                            const VkSubpassBeginInfo * pSubpassBeginInfo,
-                            const VkSubpassEndInfo *   pSubpassEndInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdNextSubpass2( commandBuffer, pSubpassBeginInfo, pSubpassEndInfo );
-    }
+      VkResult vkCreateRenderPass2( VkDevice                        device,
+                                    const VkRenderPassCreateInfo2 * pCreateInfo,
+                                    const VkAllocationCallbacks *   pAllocator,
+                                    VkRenderPass *                  pRenderPass ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateRenderPass2( device, pCreateInfo, pAllocator, pRenderPass );
+      }
 
-    void vkCmdEndRenderPass2( VkCommandBuffer commandBuffer, const VkSubpassEndInfo * pSubpassEndInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdEndRenderPass2( commandBuffer, pSubpassEndInfo );
-    }
+      void vkCmdBeginRenderPass2( VkCommandBuffer               commandBuffer,
+                                  const VkRenderPassBeginInfo * pRenderPassBegin,
+                                  const VkSubpassBeginInfo *    pSubpassBeginInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdBeginRenderPass2( commandBuffer, pRenderPassBegin, pSubpassBeginInfo );
+      }
 
-    void vkResetQueryPool( VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkResetQueryPool( device, queryPool, firstQuery, queryCount );
-    }
+      void vkCmdNextSubpass2( VkCommandBuffer            commandBuffer,
+                              const VkSubpassBeginInfo * pSubpassBeginInfo,
+                              const VkSubpassEndInfo *   pSubpassEndInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdNextSubpass2( commandBuffer, pSubpassBeginInfo, pSubpassEndInfo );
+      }
 
-    VkResult vkGetSemaphoreCounterValue( VkDevice device, VkSemaphore semaphore, uint64_t * pValue ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetSemaphoreCounterValue( device, semaphore, pValue );
-    }
+      void vkCmdEndRenderPass2( VkCommandBuffer commandBuffer, const VkSubpassEndInfo * pSubpassEndInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdEndRenderPass2( commandBuffer, pSubpassEndInfo );
+      }
 
-    VkResult vkWaitSemaphores( VkDevice device, const VkSemaphoreWaitInfo * pWaitInfo, uint64_t timeout ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkWaitSemaphores( device, pWaitInfo, timeout );
-    }
+      void vkResetQueryPool( VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkResetQueryPool( device, queryPool, firstQuery, queryCount );
+      }
 
-    VkResult vkSignalSemaphore( VkDevice device, const VkSemaphoreSignalInfo * pSignalInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkSignalSemaphore( device, pSignalInfo );
-    }
+      VkResult vkGetSemaphoreCounterValue( VkDevice device, VkSemaphore semaphore, uint64_t * pValue ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetSemaphoreCounterValue( device, semaphore, pValue );
+      }
 
-    VkDeviceAddress vkGetBufferDeviceAddress( VkDevice device, const VkBufferDeviceAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetBufferDeviceAddress( device, pInfo );
-    }
+      VkResult vkWaitSemaphores( VkDevice device, const VkSemaphoreWaitInfo * pWaitInfo, uint64_t timeout ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkWaitSemaphores( device, pWaitInfo, timeout );
+      }
 
-    uint64_t vkGetBufferOpaqueCaptureAddress( VkDevice device, const VkBufferDeviceAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetBufferOpaqueCaptureAddress( device, pInfo );
-    }
+      VkResult vkSignalSemaphore( VkDevice device, const VkSemaphoreSignalInfo * pSignalInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkSignalSemaphore( device, pSignalInfo );
+      }
 
-    uint64_t vkGetDeviceMemoryOpaqueCaptureAddress( VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetDeviceMemoryOpaqueCaptureAddress( device, pInfo );
-    }
+      VkDeviceAddress vkGetBufferDeviceAddress( VkDevice device, const VkBufferDeviceAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetBufferDeviceAddress( device, pInfo );
+      }
 
-    //=== VK_VERSION_1_3 ===
+      uint64_t vkGetBufferOpaqueCaptureAddress( VkDevice device, const VkBufferDeviceAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetBufferOpaqueCaptureAddress( device, pInfo );
+      }
 
-    VkResult vkGetPhysicalDeviceToolProperties( VkPhysicalDevice                 physicalDevice,
-                                                uint32_t *                       pToolCount,
-                                                VkPhysicalDeviceToolProperties * pToolProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceToolProperties( physicalDevice, pToolCount, pToolProperties );
-    }
+      uint64_t vkGetDeviceMemoryOpaqueCaptureAddress( VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetDeviceMemoryOpaqueCaptureAddress( device, pInfo );
+      }
 
-    VkResult vkCreatePrivateDataSlot( VkDevice                            device,
-                                      const VkPrivateDataSlotCreateInfo * pCreateInfo,
-                                      const VkAllocationCallbacks *       pAllocator,
-                                      VkPrivateDataSlot *                 pPrivateDataSlot ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreatePrivateDataSlot( device, pCreateInfo, pAllocator, pPrivateDataSlot );
-    }
+      //=== VK_VERSION_1_3 ===
 
-    void vkDestroyPrivateDataSlot( VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkDestroyPrivateDataSlot( device, privateDataSlot, pAllocator );
-    }
+      VkResult vkGetPhysicalDeviceToolProperties( VkPhysicalDevice                 physicalDevice,
+                                                  uint32_t *                       pToolCount,
+                                                  VkPhysicalDeviceToolProperties * pToolProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceToolProperties( physicalDevice, pToolCount, pToolProperties );
+      }
 
-    VkResult vkSetPrivateData( VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data ) const
-      VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkSetPrivateData( device, objectType, objectHandle, privateDataSlot, data );
-    }
+      VkResult vkCreatePrivateDataSlot( VkDevice                            device,
+                                        const VkPrivateDataSlotCreateInfo * pCreateInfo,
+                                        const VkAllocationCallbacks *       pAllocator,
+                                        VkPrivateDataSlot *                 pPrivateDataSlot ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreatePrivateDataSlot( device, pCreateInfo, pAllocator, pPrivateDataSlot );
+      }
 
-    void vkGetPrivateData( VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t * pData ) const
-      VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPrivateData( device, objectType, objectHandle, privateDataSlot, pData );
-    }
+      void vkDestroyPrivateDataSlot( VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkDestroyPrivateDataSlot( device, privateDataSlot, pAllocator );
+      }
 
-    void vkCmdSetEvent2( VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo * pDependencyInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetEvent2( commandBuffer, event, pDependencyInfo );
-    }
+      VkResult vkSetPrivateData( VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data ) const
+        VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkSetPrivateData( device, objectType, objectHandle, privateDataSlot, data );
+      }
 
-    void vkCmdResetEvent2( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdResetEvent2( commandBuffer, event, stageMask );
-    }
+      void vkGetPrivateData( VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t * pData ) const
+        VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPrivateData( device, objectType, objectHandle, privateDataSlot, pData );
+      }
 
-    void vkCmdWaitEvents2( VkCommandBuffer          commandBuffer,
-                           uint32_t                 eventCount,
-                           const VkEvent *          pEvents,
-                           const VkDependencyInfo * pDependencyInfos ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdWaitEvents2( commandBuffer, eventCount, pEvents, pDependencyInfos );
-    }
+      void vkCmdSetEvent2( VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo * pDependencyInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetEvent2( commandBuffer, event, pDependencyInfo );
+      }
 
-    void vkCmdPipelineBarrier2( VkCommandBuffer commandBuffer, const VkDependencyInfo * pDependencyInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdPipelineBarrier2( commandBuffer, pDependencyInfo );
-    }
+      void vkCmdResetEvent2( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdResetEvent2( commandBuffer, event, stageMask );
+      }
 
-    void vkCmdWriteTimestamp2( VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdWriteTimestamp2( commandBuffer, stage, queryPool, query );
-    }
+      void vkCmdWaitEvents2( VkCommandBuffer          commandBuffer,
+                             uint32_t                 eventCount,
+                             const VkEvent *          pEvents,
+                             const VkDependencyInfo * pDependencyInfos ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdWaitEvents2( commandBuffer, eventCount, pEvents, pDependencyInfos );
+      }
 
-    VkResult vkQueueSubmit2( VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 * pSubmits, VkFence fence ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkQueueSubmit2( queue, submitCount, pSubmits, fence );
-    }
+      void vkCmdPipelineBarrier2( VkCommandBuffer commandBuffer, const VkDependencyInfo * pDependencyInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdPipelineBarrier2( commandBuffer, pDependencyInfo );
+      }
 
-    void vkCmdCopyBuffer2( VkCommandBuffer commandBuffer, const VkCopyBufferInfo2 * pCopyBufferInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdCopyBuffer2( commandBuffer, pCopyBufferInfo );
-    }
+      void vkCmdWriteTimestamp2( VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdWriteTimestamp2( commandBuffer, stage, queryPool, query );
+      }
 
-    void vkCmdCopyImage2( VkCommandBuffer commandBuffer, const VkCopyImageInfo2 * pCopyImageInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdCopyImage2( commandBuffer, pCopyImageInfo );
-    }
+      VkResult vkQueueSubmit2( VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 * pSubmits, VkFence fence ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkQueueSubmit2( queue, submitCount, pSubmits, fence );
+      }
 
-    void vkCmdCopyBufferToImage2( VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2 * pCopyBufferToImageInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdCopyBufferToImage2( commandBuffer, pCopyBufferToImageInfo );
-    }
+      void vkCmdCopyBuffer2( VkCommandBuffer commandBuffer, const VkCopyBufferInfo2 * pCopyBufferInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdCopyBuffer2( commandBuffer, pCopyBufferInfo );
+      }
 
-    void vkCmdCopyImageToBuffer2( VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2 * pCopyImageToBufferInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdCopyImageToBuffer2( commandBuffer, pCopyImageToBufferInfo );
-    }
+      void vkCmdCopyImage2( VkCommandBuffer commandBuffer, const VkCopyImageInfo2 * pCopyImageInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdCopyImage2( commandBuffer, pCopyImageInfo );
+      }
 
-    void vkCmdBlitImage2( VkCommandBuffer commandBuffer, const VkBlitImageInfo2 * pBlitImageInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdBlitImage2( commandBuffer, pBlitImageInfo );
-    }
+      void vkCmdCopyBufferToImage2( VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2 * pCopyBufferToImageInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdCopyBufferToImage2( commandBuffer, pCopyBufferToImageInfo );
+      }
 
-    void vkCmdResolveImage2( VkCommandBuffer commandBuffer, const VkResolveImageInfo2 * pResolveImageInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdResolveImage2( commandBuffer, pResolveImageInfo );
-    }
+      void vkCmdCopyImageToBuffer2( VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2 * pCopyImageToBufferInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdCopyImageToBuffer2( commandBuffer, pCopyImageToBufferInfo );
+      }
 
-    void vkCmdBeginRendering( VkCommandBuffer commandBuffer, const VkRenderingInfo * pRenderingInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdBeginRendering( commandBuffer, pRenderingInfo );
-    }
+      void vkCmdBlitImage2( VkCommandBuffer commandBuffer, const VkBlitImageInfo2 * pBlitImageInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdBlitImage2( commandBuffer, pBlitImageInfo );
+      }
 
-    void vkCmdEndRendering( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdEndRendering( commandBuffer );
-    }
+      void vkCmdResolveImage2( VkCommandBuffer commandBuffer, const VkResolveImageInfo2 * pResolveImageInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdResolveImage2( commandBuffer, pResolveImageInfo );
+      }
 
-    void vkCmdSetCullMode( VkCommandBuffer commandBuffer, VkCullModeFlags cullMode ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetCullMode( commandBuffer, cullMode );
-    }
+      void vkCmdBeginRendering( VkCommandBuffer commandBuffer, const VkRenderingInfo * pRenderingInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdBeginRendering( commandBuffer, pRenderingInfo );
+      }
 
-    void vkCmdSetFrontFace( VkCommandBuffer commandBuffer, VkFrontFace frontFace ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetFrontFace( commandBuffer, frontFace );
-    }
+      void vkCmdEndRendering( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdEndRendering( commandBuffer );
+      }
 
-    void vkCmdSetPrimitiveTopology( VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetPrimitiveTopology( commandBuffer, primitiveTopology );
-    }
+      void vkCmdSetCullMode( VkCommandBuffer commandBuffer, VkCullModeFlags cullMode ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetCullMode( commandBuffer, cullMode );
+      }
 
-    void vkCmdSetViewportWithCount( VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport * pViewports ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetViewportWithCount( commandBuffer, viewportCount, pViewports );
-    }
+      void vkCmdSetFrontFace( VkCommandBuffer commandBuffer, VkFrontFace frontFace ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetFrontFace( commandBuffer, frontFace );
+      }
+
+      void vkCmdSetPrimitiveTopology( VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetPrimitiveTopology( commandBuffer, primitiveTopology );
+      }
+
+      void vkCmdSetViewportWithCount( VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport * pViewports ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetViewportWithCount( commandBuffer, viewportCount, pViewports );
+      }
 
-    void vkCmdSetScissorWithCount( VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D * pScissors ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetScissorWithCount( commandBuffer, scissorCount, pScissors );
-    }
+      void vkCmdSetScissorWithCount( VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D * pScissors ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetScissorWithCount( commandBuffer, scissorCount, pScissors );
+      }
 
-    void vkCmdBindVertexBuffers2( VkCommandBuffer      commandBuffer,
-                                  uint32_t             firstBinding,
-                                  uint32_t             bindingCount,
-                                  const VkBuffer *     pBuffers,
-                                  const VkDeviceSize * pOffsets,
-                                  const VkDeviceSize * pSizes,
-                                  const VkDeviceSize * pStrides ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdBindVertexBuffers2( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides );
-    }
+      void vkCmdBindVertexBuffers2( VkCommandBuffer      commandBuffer,
+                                    uint32_t             firstBinding,
+                                    uint32_t             bindingCount,
+                                    const VkBuffer *     pBuffers,
+                                    const VkDeviceSize * pOffsets,
+                                    const VkDeviceSize * pSizes,
+                                    const VkDeviceSize * pStrides ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdBindVertexBuffers2( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides );
+      }
 
-    void vkCmdSetDepthTestEnable( VkCommandBuffer commandBuffer, VkBool32 depthTestEnable ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetDepthTestEnable( commandBuffer, depthTestEnable );
-    }
+      void vkCmdSetDepthTestEnable( VkCommandBuffer commandBuffer, VkBool32 depthTestEnable ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetDepthTestEnable( commandBuffer, depthTestEnable );
+      }
 
-    void vkCmdSetDepthWriteEnable( VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetDepthWriteEnable( commandBuffer, depthWriteEnable );
-    }
+      void vkCmdSetDepthWriteEnable( VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetDepthWriteEnable( commandBuffer, depthWriteEnable );
+      }
 
-    void vkCmdSetDepthCompareOp( VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetDepthCompareOp( commandBuffer, depthCompareOp );
-    }
+      void vkCmdSetDepthCompareOp( VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetDepthCompareOp( commandBuffer, depthCompareOp );
+      }
 
-    void vkCmdSetDepthBoundsTestEnable( VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetDepthBoundsTestEnable( commandBuffer, depthBoundsTestEnable );
-    }
+      void vkCmdSetDepthBoundsTestEnable( VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetDepthBoundsTestEnable( commandBuffer, depthBoundsTestEnable );
+      }
 
-    void vkCmdSetStencilTestEnable( VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetStencilTestEnable( commandBuffer, stencilTestEnable );
-    }
+      void vkCmdSetStencilTestEnable( VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetStencilTestEnable( commandBuffer, stencilTestEnable );
+      }
 
-    void vkCmdSetStencilOp( VkCommandBuffer    commandBuffer,
-                            VkStencilFaceFlags faceMask,
-                            VkStencilOp        failOp,
-                            VkStencilOp        passOp,
-                            VkStencilOp        depthFailOp,
-                            VkCompareOp        compareOp ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetStencilOp( commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp );
-    }
+      void vkCmdSetStencilOp( VkCommandBuffer    commandBuffer,
+                              VkStencilFaceFlags faceMask,
+                              VkStencilOp        failOp,
+                              VkStencilOp        passOp,
+                              VkStencilOp        depthFailOp,
+                              VkCompareOp        compareOp ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetStencilOp( commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp );
+      }
 
-    void vkCmdSetRasterizerDiscardEnable( VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetRasterizerDiscardEnable( commandBuffer, rasterizerDiscardEnable );
-    }
+      void vkCmdSetRasterizerDiscardEnable( VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetRasterizerDiscardEnable( commandBuffer, rasterizerDiscardEnable );
+      }
 
-    void vkCmdSetDepthBiasEnable( VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetDepthBiasEnable( commandBuffer, depthBiasEnable );
-    }
+      void vkCmdSetDepthBiasEnable( VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetDepthBiasEnable( commandBuffer, depthBiasEnable );
+      }
 
-    void vkCmdSetPrimitiveRestartEnable( VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetPrimitiveRestartEnable( commandBuffer, primitiveRestartEnable );
-    }
+      void vkCmdSetPrimitiveRestartEnable( VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetPrimitiveRestartEnable( commandBuffer, primitiveRestartEnable );
+      }
 
-    void vkGetDeviceBufferMemoryRequirements( VkDevice                                 device,
-                                              const VkDeviceBufferMemoryRequirements * pInfo,
-                                              VkMemoryRequirements2 *                  pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetDeviceBufferMemoryRequirements( device, pInfo, pMemoryRequirements );
-    }
+      void vkGetDeviceBufferMemoryRequirements( VkDevice                                 device,
+                                                const VkDeviceBufferMemoryRequirements * pInfo,
+                                                VkMemoryRequirements2 *                  pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetDeviceBufferMemoryRequirements( device, pInfo, pMemoryRequirements );
+      }
 
-    void vkGetDeviceImageMemoryRequirements( VkDevice                                device,
-                                             const VkDeviceImageMemoryRequirements * pInfo,
-                                             VkMemoryRequirements2 *                 pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetDeviceImageMemoryRequirements( device, pInfo, pMemoryRequirements );
-    }
+      void vkGetDeviceImageMemoryRequirements( VkDevice                                device,
+                                               const VkDeviceImageMemoryRequirements * pInfo,
+                                               VkMemoryRequirements2 *                 pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetDeviceImageMemoryRequirements( device, pInfo, pMemoryRequirements );
+      }
 
-    void vkGetDeviceImageSparseMemoryRequirements( VkDevice                                device,
-                                                   const VkDeviceImageMemoryRequirements * pInfo,
-                                                   uint32_t *                              pSparseMemoryRequirementCount,
-                                                   VkSparseImageMemoryRequirements2 *      pSparseMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetDeviceImageSparseMemoryRequirements( device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements );
-    }
+      void vkGetDeviceImageSparseMemoryRequirements( VkDevice                                device,
+                                                     const VkDeviceImageMemoryRequirements * pInfo,
+                                                     uint32_t *                              pSparseMemoryRequirementCount,
+                                                     VkSparseImageMemoryRequirements2 *      pSparseMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetDeviceImageSparseMemoryRequirements( device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements );
+      }
 
-    //=== VK_KHR_surface ===
+      //=== VK_KHR_surface ===
 
-    void vkDestroySurfaceKHR( VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkDestroySurfaceKHR( instance, surface, pAllocator );
-    }
+      void vkDestroySurfaceKHR( VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkDestroySurfaceKHR( instance, surface, pAllocator );
+      }
 
-    VkResult vkGetPhysicalDeviceSurfaceSupportKHR( VkPhysicalDevice physicalDevice,
-                                                   uint32_t         queueFamilyIndex,
-                                                   VkSurfaceKHR     surface,
-                                                   VkBool32 *       pSupported ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceSurfaceSupportKHR( physicalDevice, queueFamilyIndex, surface, pSupported );
-    }
+      VkResult vkGetPhysicalDeviceSurfaceSupportKHR( VkPhysicalDevice physicalDevice,
+                                                     uint32_t         queueFamilyIndex,
+                                                     VkSurfaceKHR     surface,
+                                                     VkBool32 *       pSupported ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceSurfaceSupportKHR( physicalDevice, queueFamilyIndex, surface, pSupported );
+      }
 
-    VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR( VkPhysicalDevice           physicalDevice,
-                                                        VkSurfaceKHR               surface,
-                                                        VkSurfaceCapabilitiesKHR * pSurfaceCapabilities ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceSurfaceCapabilitiesKHR( physicalDevice, surface, pSurfaceCapabilities );
-    }
+      VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR( VkPhysicalDevice           physicalDevice,
+                                                          VkSurfaceKHR               surface,
+                                                          VkSurfaceCapabilitiesKHR * pSurfaceCapabilities ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceSurfaceCapabilitiesKHR( physicalDevice, surface, pSurfaceCapabilities );
+      }
 
-    VkResult vkGetPhysicalDeviceSurfaceFormatsKHR( VkPhysicalDevice     physicalDevice,
-                                                   VkSurfaceKHR         surface,
-                                                   uint32_t *           pSurfaceFormatCount,
-                                                   VkSurfaceFormatKHR * pSurfaceFormats ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceSurfaceFormatsKHR( physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats );
-    }
+      VkResult vkGetPhysicalDeviceSurfaceFormatsKHR( VkPhysicalDevice     physicalDevice,
+                                                     VkSurfaceKHR         surface,
+                                                     uint32_t *           pSurfaceFormatCount,
+                                                     VkSurfaceFormatKHR * pSurfaceFormats ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceSurfaceFormatsKHR( physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats );
+      }
 
-    VkResult vkGetPhysicalDeviceSurfacePresentModesKHR( VkPhysicalDevice   physicalDevice,
-                                                        VkSurfaceKHR       surface,
-                                                        uint32_t *         pPresentModeCount,
-                                                        VkPresentModeKHR * pPresentModes ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceSurfacePresentModesKHR( physicalDevice, surface, pPresentModeCount, pPresentModes );
-    }
+      VkResult vkGetPhysicalDeviceSurfacePresentModesKHR( VkPhysicalDevice   physicalDevice,
+                                                          VkSurfaceKHR       surface,
+                                                          uint32_t *         pPresentModeCount,
+                                                          VkPresentModeKHR * pPresentModes ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceSurfacePresentModesKHR( physicalDevice, surface, pPresentModeCount, pPresentModes );
+      }
 
-    //=== VK_KHR_swapchain ===
+      //=== VK_KHR_swapchain ===
 
-    VkResult vkCreateSwapchainKHR( VkDevice                         device,
-                                   const VkSwapchainCreateInfoKHR * pCreateInfo,
-                                   const VkAllocationCallbacks *    pAllocator,
-                                   VkSwapchainKHR *                 pSwapchain ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateSwapchainKHR( device, pCreateInfo, pAllocator, pSwapchain );
-    }
+      VkResult vkCreateSwapchainKHR( VkDevice                         device,
+                                     const VkSwapchainCreateInfoKHR * pCreateInfo,
+                                     const VkAllocationCallbacks *    pAllocator,
+                                     VkSwapchainKHR *                 pSwapchain ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateSwapchainKHR( device, pCreateInfo, pAllocator, pSwapchain );
+      }
 
-    void vkDestroySwapchainKHR( VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkDestroySwapchainKHR( device, swapchain, pAllocator );
-    }
+      void vkDestroySwapchainKHR( VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkDestroySwapchainKHR( device, swapchain, pAllocator );
+      }
 
-    VkResult vkGetSwapchainImagesKHR( VkDevice       device,
-                                      VkSwapchainKHR swapchain,
-                                      uint32_t *     pSwapchainImageCount,
-                                      VkImage *      pSwapchainImages ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetSwapchainImagesKHR( device, swapchain, pSwapchainImageCount, pSwapchainImages );
-    }
+      VkResult vkGetSwapchainImagesKHR( VkDevice       device,
+                                        VkSwapchainKHR swapchain,
+                                        uint32_t *     pSwapchainImageCount,
+                                        VkImage *      pSwapchainImages ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetSwapchainImagesKHR( device, swapchain, pSwapchainImageCount, pSwapchainImages );
+      }
 
-    VkResult vkAcquireNextImageKHR(
-      VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t * pImageIndex ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkAcquireNextImageKHR( device, swapchain, timeout, semaphore, fence, pImageIndex );
-    }
+      VkResult vkAcquireNextImageKHR(
+        VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t * pImageIndex ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkAcquireNextImageKHR( device, swapchain, timeout, semaphore, fence, pImageIndex );
+      }
 
-    VkResult vkQueuePresentKHR( VkQueue queue, const VkPresentInfoKHR * pPresentInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkQueuePresentKHR( queue, pPresentInfo );
-    }
+      VkResult vkQueuePresentKHR( VkQueue queue, const VkPresentInfoKHR * pPresentInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkQueuePresentKHR( queue, pPresentInfo );
+      }
 
-    VkResult vkGetDeviceGroupPresentCapabilitiesKHR( VkDevice                              device,
-                                                     VkDeviceGroupPresentCapabilitiesKHR * pDeviceGroupPresentCapabilities ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetDeviceGroupPresentCapabilitiesKHR( device, pDeviceGroupPresentCapabilities );
-    }
+      VkResult vkGetDeviceGroupPresentCapabilitiesKHR( VkDevice                              device,
+                                                       VkDeviceGroupPresentCapabilitiesKHR * pDeviceGroupPresentCapabilities ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetDeviceGroupPresentCapabilitiesKHR( device, pDeviceGroupPresentCapabilities );
+      }
 
-    VkResult
-      vkGetDeviceGroupSurfacePresentModesKHR( VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR * pModes ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetDeviceGroupSurfacePresentModesKHR( device, surface, pModes );
-    }
+      VkResult
+        vkGetDeviceGroupSurfacePresentModesKHR( VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR * pModes ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetDeviceGroupSurfacePresentModesKHR( device, surface, pModes );
+      }
 
-    VkResult vkGetPhysicalDevicePresentRectanglesKHR( VkPhysicalDevice physicalDevice,
-                                                      VkSurfaceKHR     surface,
-                                                      uint32_t *       pRectCount,
-                                                      VkRect2D *       pRects ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDevicePresentRectanglesKHR( physicalDevice, surface, pRectCount, pRects );
-    }
+      VkResult vkGetPhysicalDevicePresentRectanglesKHR( VkPhysicalDevice physicalDevice,
+                                                        VkSurfaceKHR     surface,
+                                                        uint32_t *       pRectCount,
+                                                        VkRect2D *       pRects ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDevicePresentRectanglesKHR( physicalDevice, surface, pRectCount, pRects );
+      }
 
-    VkResult vkAcquireNextImage2KHR( VkDevice device, const VkAcquireNextImageInfoKHR * pAcquireInfo, uint32_t * pImageIndex ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkAcquireNextImage2KHR( device, pAcquireInfo, pImageIndex );
-    }
+      VkResult vkAcquireNextImage2KHR( VkDevice device, const VkAcquireNextImageInfoKHR * pAcquireInfo, uint32_t * pImageIndex ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkAcquireNextImage2KHR( device, pAcquireInfo, pImageIndex );
+      }
 
-    //=== VK_KHR_display ===
+      //=== VK_KHR_display ===
 
-    VkResult vkGetPhysicalDeviceDisplayPropertiesKHR( VkPhysicalDevice         physicalDevice,
-                                                      uint32_t *               pPropertyCount,
-                                                      VkDisplayPropertiesKHR * pProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceDisplayPropertiesKHR( physicalDevice, pPropertyCount, pProperties );
-    }
+      VkResult vkGetPhysicalDeviceDisplayPropertiesKHR( VkPhysicalDevice         physicalDevice,
+                                                        uint32_t *               pPropertyCount,
+                                                        VkDisplayPropertiesKHR * pProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceDisplayPropertiesKHR( physicalDevice, pPropertyCount, pProperties );
+      }
 
-    VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR( VkPhysicalDevice              physicalDevice,
-                                                           uint32_t *                    pPropertyCount,
-                                                           VkDisplayPlanePropertiesKHR * pProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceDisplayPlanePropertiesKHR( physicalDevice, pPropertyCount, pProperties );
-    }
+      VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR( VkPhysicalDevice              physicalDevice,
+                                                             uint32_t *                    pPropertyCount,
+                                                             VkDisplayPlanePropertiesKHR * pProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceDisplayPlanePropertiesKHR( physicalDevice, pPropertyCount, pProperties );
+      }
 
-    VkResult vkGetDisplayPlaneSupportedDisplaysKHR( VkPhysicalDevice physicalDevice,
-                                                    uint32_t         planeIndex,
-                                                    uint32_t *       pDisplayCount,
-                                                    VkDisplayKHR *   pDisplays ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetDisplayPlaneSupportedDisplaysKHR( physicalDevice, planeIndex, pDisplayCount, pDisplays );
-    }
+      VkResult vkGetDisplayPlaneSupportedDisplaysKHR( VkPhysicalDevice physicalDevice,
+                                                      uint32_t         planeIndex,
+                                                      uint32_t *       pDisplayCount,
+                                                      VkDisplayKHR *   pDisplays ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetDisplayPlaneSupportedDisplaysKHR( physicalDevice, planeIndex, pDisplayCount, pDisplays );
+      }
 
-    VkResult vkGetDisplayModePropertiesKHR( VkPhysicalDevice             physicalDevice,
-                                            VkDisplayKHR                 display,
-                                            uint32_t *                   pPropertyCount,
-                                            VkDisplayModePropertiesKHR * pProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetDisplayModePropertiesKHR( physicalDevice, display, pPropertyCount, pProperties );
-    }
+      VkResult vkGetDisplayModePropertiesKHR( VkPhysicalDevice             physicalDevice,
+                                              VkDisplayKHR                 display,
+                                              uint32_t *                   pPropertyCount,
+                                              VkDisplayModePropertiesKHR * pProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetDisplayModePropertiesKHR( physicalDevice, display, pPropertyCount, pProperties );
+      }
 
-    VkResult vkCreateDisplayModeKHR( VkPhysicalDevice                   physicalDevice,
-                                     VkDisplayKHR                       display,
-                                     const VkDisplayModeCreateInfoKHR * pCreateInfo,
-                                     const VkAllocationCallbacks *      pAllocator,
-                                     VkDisplayModeKHR *                 pMode ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateDisplayModeKHR( physicalDevice, display, pCreateInfo, pAllocator, pMode );
-    }
+      VkResult vkCreateDisplayModeKHR( VkPhysicalDevice                   physicalDevice,
+                                       VkDisplayKHR                       display,
+                                       const VkDisplayModeCreateInfoKHR * pCreateInfo,
+                                       const VkAllocationCallbacks *      pAllocator,
+                                       VkDisplayModeKHR *                 pMode ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateDisplayModeKHR( physicalDevice, display, pCreateInfo, pAllocator, pMode );
+      }
 
-    VkResult vkGetDisplayPlaneCapabilitiesKHR( VkPhysicalDevice                physicalDevice,
-                                               VkDisplayModeKHR                mode,
-                                               uint32_t                        planeIndex,
-                                               VkDisplayPlaneCapabilitiesKHR * pCapabilities ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetDisplayPlaneCapabilitiesKHR( physicalDevice, mode, planeIndex, pCapabilities );
-    }
+      VkResult vkGetDisplayPlaneCapabilitiesKHR( VkPhysicalDevice                physicalDevice,
+                                                 VkDisplayModeKHR                mode,
+                                                 uint32_t                        planeIndex,
+                                                 VkDisplayPlaneCapabilitiesKHR * pCapabilities ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetDisplayPlaneCapabilitiesKHR( physicalDevice, mode, planeIndex, pCapabilities );
+      }
 
-    VkResult vkCreateDisplayPlaneSurfaceKHR( VkInstance                            instance,
-                                             const VkDisplaySurfaceCreateInfoKHR * pCreateInfo,
-                                             const VkAllocationCallbacks *         pAllocator,
-                                             VkSurfaceKHR *                        pSurface ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateDisplayPlaneSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
-    }
+      VkResult vkCreateDisplayPlaneSurfaceKHR( VkInstance                            instance,
+                                               const VkDisplaySurfaceCreateInfoKHR * pCreateInfo,
+                                               const VkAllocationCallbacks *         pAllocator,
+                                               VkSurfaceKHR *                        pSurface ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateDisplayPlaneSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
+      }
 
-    //=== VK_KHR_display_swapchain ===
+      //=== VK_KHR_display_swapchain ===
 
-    VkResult vkCreateSharedSwapchainsKHR( VkDevice                         device,
-                                          uint32_t                         swapchainCount,
-                                          const VkSwapchainCreateInfoKHR * pCreateInfos,
-                                          const VkAllocationCallbacks *    pAllocator,
-                                          VkSwapchainKHR *                 pSwapchains ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateSharedSwapchainsKHR( device, swapchainCount, pCreateInfos, pAllocator, pSwapchains );
-    }
+      VkResult vkCreateSharedSwapchainsKHR( VkDevice                         device,
+                                            uint32_t                         swapchainCount,
+                                            const VkSwapchainCreateInfoKHR * pCreateInfos,
+                                            const VkAllocationCallbacks *    pAllocator,
+                                            VkSwapchainKHR *                 pSwapchains ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateSharedSwapchainsKHR( device, swapchainCount, pCreateInfos, pAllocator, pSwapchains );
+      }
 
 #  if defined( VK_USE_PLATFORM_XLIB_KHR )
-    //=== VK_KHR_xlib_surface ===
+      //=== VK_KHR_xlib_surface ===
 
-    VkResult vkCreateXlibSurfaceKHR( VkInstance                         instance,
-                                     const VkXlibSurfaceCreateInfoKHR * pCreateInfo,
-                                     const VkAllocationCallbacks *      pAllocator,
-                                     VkSurfaceKHR *                     pSurface ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateXlibSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
-    }
+      VkResult vkCreateXlibSurfaceKHR( VkInstance                         instance,
+                                       const VkXlibSurfaceCreateInfoKHR * pCreateInfo,
+                                       const VkAllocationCallbacks *      pAllocator,
+                                       VkSurfaceKHR *                     pSurface ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateXlibSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
+      }
 
-    VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR( VkPhysicalDevice physicalDevice,
-                                                            uint32_t         queueFamilyIndex,
-                                                            Display *        dpy,
-                                                            VisualID         visualID ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceXlibPresentationSupportKHR( physicalDevice, queueFamilyIndex, dpy, visualID );
-    }
+      VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR( VkPhysicalDevice physicalDevice,
+                                                              uint32_t         queueFamilyIndex,
+                                                              Display *        dpy,
+                                                              VisualID         visualID ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceXlibPresentationSupportKHR( physicalDevice, queueFamilyIndex, dpy, visualID );
+      }
 #  endif /*VK_USE_PLATFORM_XLIB_KHR*/
 
 #  if defined( VK_USE_PLATFORM_XCB_KHR )
-    //=== VK_KHR_xcb_surface ===
+      //=== VK_KHR_xcb_surface ===
 
-    VkResult vkCreateXcbSurfaceKHR( VkInstance                        instance,
-                                    const VkXcbSurfaceCreateInfoKHR * pCreateInfo,
-                                    const VkAllocationCallbacks *     pAllocator,
-                                    VkSurfaceKHR *                    pSurface ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateXcbSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
-    }
+      VkResult vkCreateXcbSurfaceKHR( VkInstance                        instance,
+                                      const VkXcbSurfaceCreateInfoKHR * pCreateInfo,
+                                      const VkAllocationCallbacks *     pAllocator,
+                                      VkSurfaceKHR *                    pSurface ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateXcbSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
+      }
 
-    VkBool32 vkGetPhysicalDeviceXcbPresentationSupportKHR( VkPhysicalDevice   physicalDevice,
-                                                           uint32_t           queueFamilyIndex,
-                                                           xcb_connection_t * connection,
-                                                           xcb_visualid_t     visual_id ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceXcbPresentationSupportKHR( physicalDevice, queueFamilyIndex, connection, visual_id );
-    }
+      VkBool32 vkGetPhysicalDeviceXcbPresentationSupportKHR( VkPhysicalDevice   physicalDevice,
+                                                             uint32_t           queueFamilyIndex,
+                                                             xcb_connection_t * connection,
+                                                             xcb_visualid_t     visual_id ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceXcbPresentationSupportKHR( physicalDevice, queueFamilyIndex, connection, visual_id );
+      }
 #  endif /*VK_USE_PLATFORM_XCB_KHR*/
 
 #  if defined( VK_USE_PLATFORM_WAYLAND_KHR )
-    //=== VK_KHR_wayland_surface ===
+      //=== VK_KHR_wayland_surface ===
 
-    VkResult vkCreateWaylandSurfaceKHR( VkInstance                            instance,
-                                        const VkWaylandSurfaceCreateInfoKHR * pCreateInfo,
-                                        const VkAllocationCallbacks *         pAllocator,
-                                        VkSurfaceKHR *                        pSurface ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateWaylandSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
-    }
+      VkResult vkCreateWaylandSurfaceKHR( VkInstance                            instance,
+                                          const VkWaylandSurfaceCreateInfoKHR * pCreateInfo,
+                                          const VkAllocationCallbacks *         pAllocator,
+                                          VkSurfaceKHR *                        pSurface ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateWaylandSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
+      }
 
-    VkBool32 vkGetPhysicalDeviceWaylandPresentationSupportKHR( VkPhysicalDevice    physicalDevice,
-                                                               uint32_t            queueFamilyIndex,
-                                                               struct wl_display * display ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceWaylandPresentationSupportKHR( physicalDevice, queueFamilyIndex, display );
-    }
+      VkBool32 vkGetPhysicalDeviceWaylandPresentationSupportKHR( VkPhysicalDevice    physicalDevice,
+                                                                 uint32_t            queueFamilyIndex,
+                                                                 struct wl_display * display ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceWaylandPresentationSupportKHR( physicalDevice, queueFamilyIndex, display );
+      }
 #  endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
 
 #  if defined( VK_USE_PLATFORM_ANDROID_KHR )
-    //=== VK_KHR_android_surface ===
+      //=== VK_KHR_android_surface ===
 
-    VkResult vkCreateAndroidSurfaceKHR( VkInstance                            instance,
-                                        const VkAndroidSurfaceCreateInfoKHR * pCreateInfo,
-                                        const VkAllocationCallbacks *         pAllocator,
-                                        VkSurfaceKHR *                        pSurface ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateAndroidSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
-    }
+      VkResult vkCreateAndroidSurfaceKHR( VkInstance                            instance,
+                                          const VkAndroidSurfaceCreateInfoKHR * pCreateInfo,
+                                          const VkAllocationCallbacks *         pAllocator,
+                                          VkSurfaceKHR *                        pSurface ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateAndroidSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
+      }
 #  endif /*VK_USE_PLATFORM_ANDROID_KHR*/
 
 #  if defined( VK_USE_PLATFORM_WIN32_KHR )
-    //=== VK_KHR_win32_surface ===
+      //=== VK_KHR_win32_surface ===
 
-    VkResult vkCreateWin32SurfaceKHR( VkInstance                          instance,
-                                      const VkWin32SurfaceCreateInfoKHR * pCreateInfo,
-                                      const VkAllocationCallbacks *       pAllocator,
-                                      VkSurfaceKHR *                      pSurface ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateWin32SurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
-    }
+      VkResult vkCreateWin32SurfaceKHR( VkInstance                          instance,
+                                        const VkWin32SurfaceCreateInfoKHR * pCreateInfo,
+                                        const VkAllocationCallbacks *       pAllocator,
+                                        VkSurfaceKHR *                      pSurface ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateWin32SurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
+      }
 
-    VkBool32 vkGetPhysicalDeviceWin32PresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceWin32PresentationSupportKHR( physicalDevice, queueFamilyIndex );
-    }
+      VkBool32 vkGetPhysicalDeviceWin32PresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceWin32PresentationSupportKHR( physicalDevice, queueFamilyIndex );
+      }
 #  endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
-    //=== VK_EXT_debug_report ===
+      //=== VK_EXT_debug_report ===
 
-    VkResult vkCreateDebugReportCallbackEXT( VkInstance                                 instance,
-                                             const VkDebugReportCallbackCreateInfoEXT * pCreateInfo,
-                                             const VkAllocationCallbacks *              pAllocator,
-                                             VkDebugReportCallbackEXT *                 pCallback ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateDebugReportCallbackEXT( instance, pCreateInfo, pAllocator, pCallback );
-    }
+      VkResult vkCreateDebugReportCallbackEXT( VkInstance                                 instance,
+                                               const VkDebugReportCallbackCreateInfoEXT * pCreateInfo,
+                                               const VkAllocationCallbacks *              pAllocator,
+                                               VkDebugReportCallbackEXT *                 pCallback ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateDebugReportCallbackEXT( instance, pCreateInfo, pAllocator, pCallback );
+      }
 
-    void vkDestroyDebugReportCallbackEXT( VkInstance                    instance,
-                                          VkDebugReportCallbackEXT      callback,
-                                          const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkDestroyDebugReportCallbackEXT( instance, callback, pAllocator );
-    }
+      void vkDestroyDebugReportCallbackEXT( VkInstance                    instance,
+                                            VkDebugReportCallbackEXT      callback,
+                                            const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkDestroyDebugReportCallbackEXT( instance, callback, pAllocator );
+      }
 
-    void vkDebugReportMessageEXT( VkInstance                 instance,
-                                  VkDebugReportFlagsEXT      flags,
-                                  VkDebugReportObjectTypeEXT objectType,
-                                  uint64_t                   object,
-                                  size_t                     location,
-                                  int32_t                    messageCode,
-                                  const char *               pLayerPrefix,
-                                  const char *               pMessage ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkDebugReportMessageEXT( instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage );
-    }
+      void vkDebugReportMessageEXT( VkInstance                 instance,
+                                    VkDebugReportFlagsEXT      flags,
+                                    VkDebugReportObjectTypeEXT objectType,
+                                    uint64_t                   object,
+                                    size_t                     location,
+                                    int32_t                    messageCode,
+                                    const char *               pLayerPrefix,
+                                    const char *               pMessage ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkDebugReportMessageEXT( instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage );
+      }
 
-    //=== VK_EXT_debug_marker ===
+      //=== VK_EXT_debug_marker ===
 
-    VkResult vkDebugMarkerSetObjectTagEXT( VkDevice device, const VkDebugMarkerObjectTagInfoEXT * pTagInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkDebugMarkerSetObjectTagEXT( device, pTagInfo );
-    }
+      VkResult vkDebugMarkerSetObjectTagEXT( VkDevice device, const VkDebugMarkerObjectTagInfoEXT * pTagInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkDebugMarkerSetObjectTagEXT( device, pTagInfo );
+      }
 
-    VkResult vkDebugMarkerSetObjectNameEXT( VkDevice device, const VkDebugMarkerObjectNameInfoEXT * pNameInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkDebugMarkerSetObjectNameEXT( device, pNameInfo );
-    }
+      VkResult vkDebugMarkerSetObjectNameEXT( VkDevice device, const VkDebugMarkerObjectNameInfoEXT * pNameInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkDebugMarkerSetObjectNameEXT( device, pNameInfo );
+      }
 
-    void vkCmdDebugMarkerBeginEXT( VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT * pMarkerInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdDebugMarkerBeginEXT( commandBuffer, pMarkerInfo );
-    }
+      void vkCmdDebugMarkerBeginEXT( VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT * pMarkerInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdDebugMarkerBeginEXT( commandBuffer, pMarkerInfo );
+      }
 
-    void vkCmdDebugMarkerEndEXT( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdDebugMarkerEndEXT( commandBuffer );
-    }
+      void vkCmdDebugMarkerEndEXT( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdDebugMarkerEndEXT( commandBuffer );
+      }
 
-    void vkCmdDebugMarkerInsertEXT( VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT * pMarkerInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdDebugMarkerInsertEXT( commandBuffer, pMarkerInfo );
-    }
+      void vkCmdDebugMarkerInsertEXT( VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT * pMarkerInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdDebugMarkerInsertEXT( commandBuffer, pMarkerInfo );
+      }
 
-    //=== VK_KHR_video_queue ===
+      //=== VK_KHR_video_queue ===
 
-    VkResult vkGetPhysicalDeviceVideoCapabilitiesKHR( VkPhysicalDevice              physicalDevice,
-                                                      const VkVideoProfileInfoKHR * pVideoProfile,
-                                                      VkVideoCapabilitiesKHR *      pCapabilities ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceVideoCapabilitiesKHR( physicalDevice, pVideoProfile, pCapabilities );
-    }
+      VkResult vkGetPhysicalDeviceVideoCapabilitiesKHR( VkPhysicalDevice              physicalDevice,
+                                                        const VkVideoProfileInfoKHR * pVideoProfile,
+                                                        VkVideoCapabilitiesKHR *      pCapabilities ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceVideoCapabilitiesKHR( physicalDevice, pVideoProfile, pCapabilities );
+      }
 
-    VkResult vkGetPhysicalDeviceVideoFormatPropertiesKHR( VkPhysicalDevice                           physicalDevice,
-                                                          const VkPhysicalDeviceVideoFormatInfoKHR * pVideoFormatInfo,
-                                                          uint32_t *                                 pVideoFormatPropertyCount,
-                                                          VkVideoFormatPropertiesKHR *               pVideoFormatProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceVideoFormatPropertiesKHR( physicalDevice, pVideoFormatInfo, pVideoFormatPropertyCount, pVideoFormatProperties );
-    }
+      VkResult vkGetPhysicalDeviceVideoFormatPropertiesKHR( VkPhysicalDevice                           physicalDevice,
+                                                            const VkPhysicalDeviceVideoFormatInfoKHR * pVideoFormatInfo,
+                                                            uint32_t *                                 pVideoFormatPropertyCount,
+                                                            VkVideoFormatPropertiesKHR *               pVideoFormatProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceVideoFormatPropertiesKHR( physicalDevice, pVideoFormatInfo, pVideoFormatPropertyCount, pVideoFormatProperties );
+      }
 
-    VkResult vkCreateVideoSessionKHR( VkDevice                            device,
-                                      const VkVideoSessionCreateInfoKHR * pCreateInfo,
-                                      const VkAllocationCallbacks *       pAllocator,
-                                      VkVideoSessionKHR *                 pVideoSession ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateVideoSessionKHR( device, pCreateInfo, pAllocator, pVideoSession );
-    }
+      VkResult vkCreateVideoSessionKHR( VkDevice                            device,
+                                        const VkVideoSessionCreateInfoKHR * pCreateInfo,
+                                        const VkAllocationCallbacks *       pAllocator,
+                                        VkVideoSessionKHR *                 pVideoSession ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateVideoSessionKHR( device, pCreateInfo, pAllocator, pVideoSession );
+      }
 
-    void vkDestroyVideoSessionKHR( VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkDestroyVideoSessionKHR( device, videoSession, pAllocator );
-    }
+      void vkDestroyVideoSessionKHR( VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkDestroyVideoSessionKHR( device, videoSession, pAllocator );
+      }
 
-    VkResult vkGetVideoSessionMemoryRequirementsKHR( VkDevice                              device,
-                                                     VkVideoSessionKHR                     videoSession,
-                                                     uint32_t *                            pMemoryRequirementsCount,
-                                                     VkVideoSessionMemoryRequirementsKHR * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetVideoSessionMemoryRequirementsKHR( device, videoSession, pMemoryRequirementsCount, pMemoryRequirements );
-    }
+      VkResult vkGetVideoSessionMemoryRequirementsKHR( VkDevice                              device,
+                                                       VkVideoSessionKHR                     videoSession,
+                                                       uint32_t *                            pMemoryRequirementsCount,
+                                                       VkVideoSessionMemoryRequirementsKHR * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetVideoSessionMemoryRequirementsKHR( device, videoSession, pMemoryRequirementsCount, pMemoryRequirements );
+      }
 
-    VkResult vkBindVideoSessionMemoryKHR( VkDevice                                device,
-                                          VkVideoSessionKHR                       videoSession,
-                                          uint32_t                                bindSessionMemoryInfoCount,
-                                          const VkBindVideoSessionMemoryInfoKHR * pBindSessionMemoryInfos ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkBindVideoSessionMemoryKHR( device, videoSession, bindSessionMemoryInfoCount, pBindSessionMemoryInfos );
-    }
+      VkResult vkBindVideoSessionMemoryKHR( VkDevice                                device,
+                                            VkVideoSessionKHR                       videoSession,
+                                            uint32_t                                bindSessionMemoryInfoCount,
+                                            const VkBindVideoSessionMemoryInfoKHR * pBindSessionMemoryInfos ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkBindVideoSessionMemoryKHR( device, videoSession, bindSessionMemoryInfoCount, pBindSessionMemoryInfos );
+      }
 
-    VkResult vkCreateVideoSessionParametersKHR( VkDevice                                      device,
-                                                const VkVideoSessionParametersCreateInfoKHR * pCreateInfo,
-                                                const VkAllocationCallbacks *                 pAllocator,
-                                                VkVideoSessionParametersKHR *                 pVideoSessionParameters ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateVideoSessionParametersKHR( device, pCreateInfo, pAllocator, pVideoSessionParameters );
-    }
+      VkResult vkCreateVideoSessionParametersKHR( VkDevice                                      device,
+                                                  const VkVideoSessionParametersCreateInfoKHR * pCreateInfo,
+                                                  const VkAllocationCallbacks *                 pAllocator,
+                                                  VkVideoSessionParametersKHR *                 pVideoSessionParameters ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateVideoSessionParametersKHR( device, pCreateInfo, pAllocator, pVideoSessionParameters );
+      }
 
-    VkResult vkUpdateVideoSessionParametersKHR( VkDevice                                      device,
-                                                VkVideoSessionParametersKHR                   videoSessionParameters,
-                                                const VkVideoSessionParametersUpdateInfoKHR * pUpdateInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkUpdateVideoSessionParametersKHR( device, videoSessionParameters, pUpdateInfo );
-    }
+      VkResult vkUpdateVideoSessionParametersKHR( VkDevice                                      device,
+                                                  VkVideoSessionParametersKHR                   videoSessionParameters,
+                                                  const VkVideoSessionParametersUpdateInfoKHR * pUpdateInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkUpdateVideoSessionParametersKHR( device, videoSessionParameters, pUpdateInfo );
+      }
 
-    void vkDestroyVideoSessionParametersKHR( VkDevice                      device,
-                                             VkVideoSessionParametersKHR   videoSessionParameters,
-                                             const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkDestroyVideoSessionParametersKHR( device, videoSessionParameters, pAllocator );
-    }
+      void vkDestroyVideoSessionParametersKHR( VkDevice                      device,
+                                               VkVideoSessionParametersKHR   videoSessionParameters,
+                                               const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkDestroyVideoSessionParametersKHR( device, videoSessionParameters, pAllocator );
+      }
 
-    void vkCmdBeginVideoCodingKHR( VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR * pBeginInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdBeginVideoCodingKHR( commandBuffer, pBeginInfo );
-    }
+      void vkCmdBeginVideoCodingKHR( VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR * pBeginInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdBeginVideoCodingKHR( commandBuffer, pBeginInfo );
+      }
 
-    void vkCmdEndVideoCodingKHR( VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR * pEndCodingInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdEndVideoCodingKHR( commandBuffer, pEndCodingInfo );
-    }
+      void vkCmdEndVideoCodingKHR( VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR * pEndCodingInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdEndVideoCodingKHR( commandBuffer, pEndCodingInfo );
+      }
 
-    void vkCmdControlVideoCodingKHR( VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR * pCodingControlInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdControlVideoCodingKHR( commandBuffer, pCodingControlInfo );
-    }
+      void vkCmdControlVideoCodingKHR( VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR * pCodingControlInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdControlVideoCodingKHR( commandBuffer, pCodingControlInfo );
+      }
 
-    //=== VK_KHR_video_decode_queue ===
+      //=== VK_KHR_video_decode_queue ===
 
-    void vkCmdDecodeVideoKHR( VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR * pDecodeInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdDecodeVideoKHR( commandBuffer, pDecodeInfo );
-    }
+      void vkCmdDecodeVideoKHR( VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR * pDecodeInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdDecodeVideoKHR( commandBuffer, pDecodeInfo );
+      }
 
-    //=== VK_EXT_transform_feedback ===
+      //=== VK_EXT_transform_feedback ===
 
-    void vkCmdBindTransformFeedbackBuffersEXT( VkCommandBuffer      commandBuffer,
-                                               uint32_t             firstBinding,
-                                               uint32_t             bindingCount,
-                                               const VkBuffer *     pBuffers,
-                                               const VkDeviceSize * pOffsets,
-                                               const VkDeviceSize * pSizes ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdBindTransformFeedbackBuffersEXT( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes );
-    }
+      void vkCmdBindTransformFeedbackBuffersEXT( VkCommandBuffer      commandBuffer,
+                                                 uint32_t             firstBinding,
+                                                 uint32_t             bindingCount,
+                                                 const VkBuffer *     pBuffers,
+                                                 const VkDeviceSize * pOffsets,
+                                                 const VkDeviceSize * pSizes ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdBindTransformFeedbackBuffersEXT( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes );
+      }
 
-    void vkCmdBeginTransformFeedbackEXT( VkCommandBuffer      commandBuffer,
+      void vkCmdBeginTransformFeedbackEXT( VkCommandBuffer      commandBuffer,
+                                           uint32_t             firstCounterBuffer,
+                                           uint32_t             counterBufferCount,
+                                           const VkBuffer *     pCounterBuffers,
+                                           const VkDeviceSize * pCounterBufferOffsets ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdBeginTransformFeedbackEXT( commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets );
+      }
+
+      void vkCmdEndTransformFeedbackEXT( VkCommandBuffer      commandBuffer,
                                          uint32_t             firstCounterBuffer,
                                          uint32_t             counterBufferCount,
                                          const VkBuffer *     pCounterBuffers,
                                          const VkDeviceSize * pCounterBufferOffsets ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdBeginTransformFeedbackEXT( commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets );
-    }
+      {
+        return ::vkCmdEndTransformFeedbackEXT( commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets );
+      }
 
-    void vkCmdEndTransformFeedbackEXT( VkCommandBuffer      commandBuffer,
-                                       uint32_t             firstCounterBuffer,
-                                       uint32_t             counterBufferCount,
-                                       const VkBuffer *     pCounterBuffers,
-                                       const VkDeviceSize * pCounterBufferOffsets ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdEndTransformFeedbackEXT( commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets );
-    }
+      void vkCmdBeginQueryIndexedEXT( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index ) const
+        VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdBeginQueryIndexedEXT( commandBuffer, queryPool, query, flags, index );
+      }
 
-    void vkCmdBeginQueryIndexedEXT( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index ) const
-      VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdBeginQueryIndexedEXT( commandBuffer, queryPool, query, flags, index );
-    }
+      void vkCmdEndQueryIndexedEXT( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdEndQueryIndexedEXT( commandBuffer, queryPool, query, index );
+      }
 
-    void vkCmdEndQueryIndexedEXT( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdEndQueryIndexedEXT( commandBuffer, queryPool, query, index );
-    }
+      void vkCmdDrawIndirectByteCountEXT( VkCommandBuffer commandBuffer,
+                                          uint32_t        instanceCount,
+                                          uint32_t        firstInstance,
+                                          VkBuffer        counterBuffer,
+                                          VkDeviceSize    counterBufferOffset,
+                                          uint32_t        counterOffset,
+                                          uint32_t        vertexStride ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdDrawIndirectByteCountEXT( commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride );
+      }
 
-    void vkCmdDrawIndirectByteCountEXT( VkCommandBuffer commandBuffer,
-                                        uint32_t        instanceCount,
-                                        uint32_t        firstInstance,
-                                        VkBuffer        counterBuffer,
-                                        VkDeviceSize    counterBufferOffset,
-                                        uint32_t        counterOffset,
-                                        uint32_t        vertexStride ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdDrawIndirectByteCountEXT( commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride );
-    }
+      //=== VK_NVX_binary_import ===
 
-    //=== VK_NVX_binary_import ===
+      VkResult vkCreateCuModuleNVX( VkDevice                        device,
+                                    const VkCuModuleCreateInfoNVX * pCreateInfo,
+                                    const VkAllocationCallbacks *   pAllocator,
+                                    VkCuModuleNVX *                 pModule ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateCuModuleNVX( device, pCreateInfo, pAllocator, pModule );
+      }
 
-    VkResult vkCreateCuModuleNVX( VkDevice                        device,
-                                  const VkCuModuleCreateInfoNVX * pCreateInfo,
-                                  const VkAllocationCallbacks *   pAllocator,
-                                  VkCuModuleNVX *                 pModule ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateCuModuleNVX( device, pCreateInfo, pAllocator, pModule );
-    }
+      VkResult vkCreateCuFunctionNVX( VkDevice                          device,
+                                      const VkCuFunctionCreateInfoNVX * pCreateInfo,
+                                      const VkAllocationCallbacks *     pAllocator,
+                                      VkCuFunctionNVX *                 pFunction ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateCuFunctionNVX( device, pCreateInfo, pAllocator, pFunction );
+      }
 
-    VkResult vkCreateCuFunctionNVX( VkDevice                          device,
-                                    const VkCuFunctionCreateInfoNVX * pCreateInfo,
-                                    const VkAllocationCallbacks *     pAllocator,
-                                    VkCuFunctionNVX *                 pFunction ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateCuFunctionNVX( device, pCreateInfo, pAllocator, pFunction );
-    }
+      void vkDestroyCuModuleNVX( VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkDestroyCuModuleNVX( device, module, pAllocator );
+      }
 
-    void vkDestroyCuModuleNVX( VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkDestroyCuModuleNVX( device, module, pAllocator );
-    }
+      void vkDestroyCuFunctionNVX( VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkDestroyCuFunctionNVX( device, function, pAllocator );
+      }
 
-    void vkDestroyCuFunctionNVX( VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkDestroyCuFunctionNVX( device, function, pAllocator );
-    }
+      void vkCmdCuLaunchKernelNVX( VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX * pLaunchInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdCuLaunchKernelNVX( commandBuffer, pLaunchInfo );
+      }
 
-    void vkCmdCuLaunchKernelNVX( VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX * pLaunchInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdCuLaunchKernelNVX( commandBuffer, pLaunchInfo );
-    }
+      //=== VK_NVX_image_view_handle ===
 
-    //=== VK_NVX_image_view_handle ===
+      uint32_t vkGetImageViewHandleNVX( VkDevice device, const VkImageViewHandleInfoNVX * pInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetImageViewHandleNVX( device, pInfo );
+      }
 
-    uint32_t vkGetImageViewHandleNVX( VkDevice device, const VkImageViewHandleInfoNVX * pInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetImageViewHandleNVX( device, pInfo );
-    }
+      VkResult vkGetImageViewAddressNVX( VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX * pProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetImageViewAddressNVX( device, imageView, pProperties );
+      }
 
-    VkResult vkGetImageViewAddressNVX( VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX * pProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetImageViewAddressNVX( device, imageView, pProperties );
-    }
+      //=== VK_AMD_draw_indirect_count ===
 
-    //=== VK_AMD_draw_indirect_count ===
+      void vkCmdDrawIndirectCountAMD( VkCommandBuffer commandBuffer,
+                                      VkBuffer        buffer,
+                                      VkDeviceSize    offset,
+                                      VkBuffer        countBuffer,
+                                      VkDeviceSize    countBufferOffset,
+                                      uint32_t        maxDrawCount,
+                                      uint32_t        stride ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdDrawIndirectCountAMD( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
+      }
 
-    void vkCmdDrawIndirectCountAMD( VkCommandBuffer commandBuffer,
-                                    VkBuffer        buffer,
-                                    VkDeviceSize    offset,
-                                    VkBuffer        countBuffer,
-                                    VkDeviceSize    countBufferOffset,
-                                    uint32_t        maxDrawCount,
-                                    uint32_t        stride ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdDrawIndirectCountAMD( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
-    }
-
-    void vkCmdDrawIndexedIndirectCountAMD( VkCommandBuffer commandBuffer,
-                                           VkBuffer        buffer,
-                                           VkDeviceSize    offset,
-                                           VkBuffer        countBuffer,
-                                           VkDeviceSize    countBufferOffset,
-                                           uint32_t        maxDrawCount,
-                                           uint32_t        stride ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdDrawIndexedIndirectCountAMD( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
-    }
-
-    //=== VK_AMD_shader_info ===
-
-    VkResult vkGetShaderInfoAMD( VkDevice              device,
-                                 VkPipeline            pipeline,
-                                 VkShaderStageFlagBits shaderStage,
-                                 VkShaderInfoTypeAMD   infoType,
-                                 size_t *              pInfoSize,
-                                 void *                pInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetShaderInfoAMD( device, pipeline, shaderStage, infoType, pInfoSize, pInfo );
-    }
-
-    //=== VK_KHR_dynamic_rendering ===
-
-    void vkCmdBeginRenderingKHR( VkCommandBuffer commandBuffer, const VkRenderingInfo * pRenderingInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdBeginRenderingKHR( commandBuffer, pRenderingInfo );
-    }
-
-    void vkCmdEndRenderingKHR( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdEndRenderingKHR( commandBuffer );
-    }
-
-#  if defined( VK_USE_PLATFORM_GGP )
-    //=== VK_GGP_stream_descriptor_surface ===
-
-    VkResult vkCreateStreamDescriptorSurfaceGGP( VkInstance                                     instance,
-                                                 const VkStreamDescriptorSurfaceCreateInfoGGP * pCreateInfo,
-                                                 const VkAllocationCallbacks *                  pAllocator,
-                                                 VkSurfaceKHR *                                 pSurface ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateStreamDescriptorSurfaceGGP( instance, pCreateInfo, pAllocator, pSurface );
-    }
-#  endif /*VK_USE_PLATFORM_GGP*/
-
-    //=== VK_NV_external_memory_capabilities ===
-
-    VkResult vkGetPhysicalDeviceExternalImageFormatPropertiesNV( VkPhysicalDevice                    physicalDevice,
-                                                                 VkFormat                            format,
-                                                                 VkImageType                         type,
-                                                                 VkImageTiling                       tiling,
-                                                                 VkImageUsageFlags                   usage,
-                                                                 VkImageCreateFlags                  flags,
-                                                                 VkExternalMemoryHandleTypeFlagsNV   externalHandleType,
-                                                                 VkExternalImageFormatPropertiesNV * pExternalImageFormatProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
-        physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties );
-    }
-
-#  if defined( VK_USE_PLATFORM_WIN32_KHR )
-    //=== VK_NV_external_memory_win32 ===
-
-    VkResult vkGetMemoryWin32HandleNV( VkDevice                          device,
-                                       VkDeviceMemory                    memory,
-                                       VkExternalMemoryHandleTypeFlagsNV handleType,
-                                       HANDLE *                          pHandle ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetMemoryWin32HandleNV( device, memory, handleType, pHandle );
-    }
-#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-    //=== VK_KHR_get_physical_device_properties2 ===
-
-    void vkGetPhysicalDeviceFeatures2KHR( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 * pFeatures ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceFeatures2KHR( physicalDevice, pFeatures );
-    }
-
-    void vkGetPhysicalDeviceProperties2KHR( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 * pProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceProperties2KHR( physicalDevice, pProperties );
-    }
-
-    void vkGetPhysicalDeviceFormatProperties2KHR( VkPhysicalDevice      physicalDevice,
-                                                  VkFormat              format,
-                                                  VkFormatProperties2 * pFormatProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceFormatProperties2KHR( physicalDevice, format, pFormatProperties );
-    }
-
-    VkResult vkGetPhysicalDeviceImageFormatProperties2KHR( VkPhysicalDevice                         physicalDevice,
-                                                           const VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo,
-                                                           VkImageFormatProperties2 *               pImageFormatProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceImageFormatProperties2KHR( physicalDevice, pImageFormatInfo, pImageFormatProperties );
-    }
-
-    void vkGetPhysicalDeviceQueueFamilyProperties2KHR( VkPhysicalDevice           physicalDevice,
-                                                       uint32_t *                 pQueueFamilyPropertyCount,
-                                                       VkQueueFamilyProperties2 * pQueueFamilyProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceQueueFamilyProperties2KHR( physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties );
-    }
-
-    void vkGetPhysicalDeviceMemoryProperties2KHR( VkPhysicalDevice                    physicalDevice,
-                                                  VkPhysicalDeviceMemoryProperties2 * pMemoryProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceMemoryProperties2KHR( physicalDevice, pMemoryProperties );
-    }
-
-    void vkGetPhysicalDeviceSparseImageFormatProperties2KHR( VkPhysicalDevice                               physicalDevice,
-                                                             const VkPhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,
-                                                             uint32_t *                                     pPropertyCount,
-                                                             VkSparseImageFormatProperties2 *               pProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceSparseImageFormatProperties2KHR( physicalDevice, pFormatInfo, pPropertyCount, pProperties );
-    }
-
-    //=== VK_KHR_device_group ===
-
-    void vkGetDeviceGroupPeerMemoryFeaturesKHR( VkDevice                   device,
-                                                uint32_t                   heapIndex,
-                                                uint32_t                   localDeviceIndex,
-                                                uint32_t                   remoteDeviceIndex,
-                                                VkPeerMemoryFeatureFlags * pPeerMemoryFeatures ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetDeviceGroupPeerMemoryFeaturesKHR( device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures );
-    }
-
-    void vkCmdSetDeviceMaskKHR( VkCommandBuffer commandBuffer, uint32_t deviceMask ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetDeviceMaskKHR( commandBuffer, deviceMask );
-    }
-
-    void vkCmdDispatchBaseKHR( VkCommandBuffer commandBuffer,
-                               uint32_t        baseGroupX,
-                               uint32_t        baseGroupY,
-                               uint32_t        baseGroupZ,
-                               uint32_t        groupCountX,
-                               uint32_t        groupCountY,
-                               uint32_t        groupCountZ ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdDispatchBaseKHR( commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ );
-    }
-
-#  if defined( VK_USE_PLATFORM_VI_NN )
-    //=== VK_NN_vi_surface ===
-
-    VkResult vkCreateViSurfaceNN( VkInstance                      instance,
-                                  const VkViSurfaceCreateInfoNN * pCreateInfo,
-                                  const VkAllocationCallbacks *   pAllocator,
-                                  VkSurfaceKHR *                  pSurface ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateViSurfaceNN( instance, pCreateInfo, pAllocator, pSurface );
-    }
-#  endif /*VK_USE_PLATFORM_VI_NN*/
-
-    //=== VK_KHR_maintenance1 ===
-
-    void vkTrimCommandPoolKHR( VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkTrimCommandPoolKHR( device, commandPool, flags );
-    }
-
-    //=== VK_KHR_device_group_creation ===
-
-    VkResult vkEnumeratePhysicalDeviceGroupsKHR( VkInstance                        instance,
-                                                 uint32_t *                        pPhysicalDeviceGroupCount,
-                                                 VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkEnumeratePhysicalDeviceGroupsKHR( instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties );
-    }
-
-    //=== VK_KHR_external_memory_capabilities ===
-
-    void vkGetPhysicalDeviceExternalBufferPropertiesKHR( VkPhysicalDevice                           physicalDevice,
-                                                         const VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo,
-                                                         VkExternalBufferProperties *               pExternalBufferProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceExternalBufferPropertiesKHR( physicalDevice, pExternalBufferInfo, pExternalBufferProperties );
-    }
-
-#  if defined( VK_USE_PLATFORM_WIN32_KHR )
-    //=== VK_KHR_external_memory_win32 ===
-
-    VkResult vkGetMemoryWin32HandleKHR( VkDevice device, const VkMemoryGetWin32HandleInfoKHR * pGetWin32HandleInfo, HANDLE * pHandle ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetMemoryWin32HandleKHR( device, pGetWin32HandleInfo, pHandle );
-    }
-
-    VkResult vkGetMemoryWin32HandlePropertiesKHR( VkDevice                           device,
-                                                  VkExternalMemoryHandleTypeFlagBits handleType,
-                                                  HANDLE                             handle,
-                                                  VkMemoryWin32HandlePropertiesKHR * pMemoryWin32HandleProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetMemoryWin32HandlePropertiesKHR( device, handleType, handle, pMemoryWin32HandleProperties );
-    }
-#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-    //=== VK_KHR_external_memory_fd ===
-
-    VkResult vkGetMemoryFdKHR( VkDevice device, const VkMemoryGetFdInfoKHR * pGetFdInfo, int * pFd ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetMemoryFdKHR( device, pGetFdInfo, pFd );
-    }
-
-    VkResult vkGetMemoryFdPropertiesKHR( VkDevice                           device,
-                                         VkExternalMemoryHandleTypeFlagBits handleType,
-                                         int                                fd,
-                                         VkMemoryFdPropertiesKHR *          pMemoryFdProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetMemoryFdPropertiesKHR( device, handleType, fd, pMemoryFdProperties );
-    }
-
-    //=== VK_KHR_external_semaphore_capabilities ===
-
-    void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( VkPhysicalDevice                              physicalDevice,
-                                                            const VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,
-                                                            VkExternalSemaphoreProperties * pExternalSemaphoreProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties );
-    }
-
-#  if defined( VK_USE_PLATFORM_WIN32_KHR )
-    //=== VK_KHR_external_semaphore_win32 ===
-
-    VkResult vkImportSemaphoreWin32HandleKHR( VkDevice                                    device,
-                                              const VkImportSemaphoreWin32HandleInfoKHR * pImportSemaphoreWin32HandleInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkImportSemaphoreWin32HandleKHR( device, pImportSemaphoreWin32HandleInfo );
-    }
-
-    VkResult
-      vkGetSemaphoreWin32HandleKHR( VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR * pGetWin32HandleInfo, HANDLE * pHandle ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetSemaphoreWin32HandleKHR( device, pGetWin32HandleInfo, pHandle );
-    }
-#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-    //=== VK_KHR_external_semaphore_fd ===
-
-    VkResult vkImportSemaphoreFdKHR( VkDevice device, const VkImportSemaphoreFdInfoKHR * pImportSemaphoreFdInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkImportSemaphoreFdKHR( device, pImportSemaphoreFdInfo );
-    }
-
-    VkResult vkGetSemaphoreFdKHR( VkDevice device, const VkSemaphoreGetFdInfoKHR * pGetFdInfo, int * pFd ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetSemaphoreFdKHR( device, pGetFdInfo, pFd );
-    }
-
-    //=== VK_KHR_push_descriptor ===
-
-    void vkCmdPushDescriptorSetKHR( VkCommandBuffer              commandBuffer,
-                                    VkPipelineBindPoint          pipelineBindPoint,
-                                    VkPipelineLayout             layout,
-                                    uint32_t                     set,
-                                    uint32_t                     descriptorWriteCount,
-                                    const VkWriteDescriptorSet * pDescriptorWrites ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdPushDescriptorSetKHR( commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites );
-    }
-
-    void vkCmdPushDescriptorSetWithTemplateKHR( VkCommandBuffer            commandBuffer,
-                                                VkDescriptorUpdateTemplate descriptorUpdateTemplate,
-                                                VkPipelineLayout           layout,
-                                                uint32_t                   set,
-                                                const void *               pData ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdPushDescriptorSetWithTemplateKHR( commandBuffer, descriptorUpdateTemplate, layout, set, pData );
-    }
-
-    //=== VK_EXT_conditional_rendering ===
-
-    void vkCmdBeginConditionalRenderingEXT( VkCommandBuffer                            commandBuffer,
-                                            const VkConditionalRenderingBeginInfoEXT * pConditionalRenderingBegin ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdBeginConditionalRenderingEXT( commandBuffer, pConditionalRenderingBegin );
-    }
-
-    void vkCmdEndConditionalRenderingEXT( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdEndConditionalRenderingEXT( commandBuffer );
-    }
-
-    //=== VK_KHR_descriptor_update_template ===
-
-    VkResult vkCreateDescriptorUpdateTemplateKHR( VkDevice                                     device,
-                                                  const VkDescriptorUpdateTemplateCreateInfo * pCreateInfo,
-                                                  const VkAllocationCallbacks *                pAllocator,
-                                                  VkDescriptorUpdateTemplate *                 pDescriptorUpdateTemplate ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateDescriptorUpdateTemplateKHR( device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate );
-    }
-
-    void vkDestroyDescriptorUpdateTemplateKHR( VkDevice                      device,
-                                               VkDescriptorUpdateTemplate    descriptorUpdateTemplate,
-                                               const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkDestroyDescriptorUpdateTemplateKHR( device, descriptorUpdateTemplate, pAllocator );
-    }
-
-    void vkUpdateDescriptorSetWithTemplateKHR( VkDevice                   device,
-                                               VkDescriptorSet            descriptorSet,
-                                               VkDescriptorUpdateTemplate descriptorUpdateTemplate,
-                                               const void *               pData ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkUpdateDescriptorSetWithTemplateKHR( device, descriptorSet, descriptorUpdateTemplate, pData );
-    }
-
-    //=== VK_NV_clip_space_w_scaling ===
-
-    void vkCmdSetViewportWScalingNV( VkCommandBuffer              commandBuffer,
-                                     uint32_t                     firstViewport,
-                                     uint32_t                     viewportCount,
-                                     const VkViewportWScalingNV * pViewportWScalings ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetViewportWScalingNV( commandBuffer, firstViewport, viewportCount, pViewportWScalings );
-    }
-
-    //=== VK_EXT_direct_mode_display ===
-
-    VkResult vkReleaseDisplayEXT( VkPhysicalDevice physicalDevice, VkDisplayKHR display ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkReleaseDisplayEXT( physicalDevice, display );
-    }
-
-#  if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
-    //=== VK_EXT_acquire_xlib_display ===
-
-    VkResult vkAcquireXlibDisplayEXT( VkPhysicalDevice physicalDevice, Display * dpy, VkDisplayKHR display ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkAcquireXlibDisplayEXT( physicalDevice, dpy, display );
-    }
-
-    VkResult vkGetRandROutputDisplayEXT( VkPhysicalDevice physicalDevice, Display * dpy, RROutput rrOutput, VkDisplayKHR * pDisplay ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetRandROutputDisplayEXT( physicalDevice, dpy, rrOutput, pDisplay );
-    }
-#  endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
-
-    //=== VK_EXT_display_surface_counter ===
-
-    VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT( VkPhysicalDevice            physicalDevice,
-                                                         VkSurfaceKHR                surface,
-                                                         VkSurfaceCapabilities2EXT * pSurfaceCapabilities ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceSurfaceCapabilities2EXT( physicalDevice, surface, pSurfaceCapabilities );
-    }
-
-    //=== VK_EXT_display_control ===
-
-    VkResult vkDisplayPowerControlEXT( VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT * pDisplayPowerInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkDisplayPowerControlEXT( device, display, pDisplayPowerInfo );
-    }
-
-    VkResult vkRegisterDeviceEventEXT( VkDevice                      device,
-                                       const VkDeviceEventInfoEXT *  pDeviceEventInfo,
-                                       const VkAllocationCallbacks * pAllocator,
-                                       VkFence *                     pFence ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkRegisterDeviceEventEXT( device, pDeviceEventInfo, pAllocator, pFence );
-    }
-
-    VkResult vkRegisterDisplayEventEXT( VkDevice                      device,
-                                        VkDisplayKHR                  display,
-                                        const VkDisplayEventInfoEXT * pDisplayEventInfo,
-                                        const VkAllocationCallbacks * pAllocator,
-                                        VkFence *                     pFence ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkRegisterDisplayEventEXT( device, display, pDisplayEventInfo, pAllocator, pFence );
-    }
-
-    VkResult vkGetSwapchainCounterEXT( VkDevice                    device,
-                                       VkSwapchainKHR              swapchain,
-                                       VkSurfaceCounterFlagBitsEXT counter,
-                                       uint64_t *                  pCounterValue ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetSwapchainCounterEXT( device, swapchain, counter, pCounterValue );
-    }
-
-    //=== VK_GOOGLE_display_timing ===
-
-    VkResult vkGetRefreshCycleDurationGOOGLE( VkDevice                       device,
-                                              VkSwapchainKHR                 swapchain,
-                                              VkRefreshCycleDurationGOOGLE * pDisplayTimingProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetRefreshCycleDurationGOOGLE( device, swapchain, pDisplayTimingProperties );
-    }
-
-    VkResult vkGetPastPresentationTimingGOOGLE( VkDevice                         device,
-                                                VkSwapchainKHR                   swapchain,
-                                                uint32_t *                       pPresentationTimingCount,
-                                                VkPastPresentationTimingGOOGLE * pPresentationTimings ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPastPresentationTimingGOOGLE( device, swapchain, pPresentationTimingCount, pPresentationTimings );
-    }
-
-    //=== VK_EXT_discard_rectangles ===
-
-    void vkCmdSetDiscardRectangleEXT( VkCommandBuffer  commandBuffer,
-                                      uint32_t         firstDiscardRectangle,
-                                      uint32_t         discardRectangleCount,
-                                      const VkRect2D * pDiscardRectangles ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetDiscardRectangleEXT( commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles );
-    }
-
-    void vkCmdSetDiscardRectangleEnableEXT( VkCommandBuffer commandBuffer, VkBool32 discardRectangleEnable ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetDiscardRectangleEnableEXT( commandBuffer, discardRectangleEnable );
-    }
-
-    void vkCmdSetDiscardRectangleModeEXT( VkCommandBuffer commandBuffer, VkDiscardRectangleModeEXT discardRectangleMode ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetDiscardRectangleModeEXT( commandBuffer, discardRectangleMode );
-    }
-
-    //=== VK_EXT_hdr_metadata ===
-
-    void vkSetHdrMetadataEXT( VkDevice                 device,
-                              uint32_t                 swapchainCount,
-                              const VkSwapchainKHR *   pSwapchains,
-                              const VkHdrMetadataEXT * pMetadata ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkSetHdrMetadataEXT( device, swapchainCount, pSwapchains, pMetadata );
-    }
-
-    //=== VK_KHR_create_renderpass2 ===
-
-    VkResult vkCreateRenderPass2KHR( VkDevice                        device,
-                                     const VkRenderPassCreateInfo2 * pCreateInfo,
-                                     const VkAllocationCallbacks *   pAllocator,
-                                     VkRenderPass *                  pRenderPass ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateRenderPass2KHR( device, pCreateInfo, pAllocator, pRenderPass );
-    }
-
-    void vkCmdBeginRenderPass2KHR( VkCommandBuffer               commandBuffer,
-                                   const VkRenderPassBeginInfo * pRenderPassBegin,
-                                   const VkSubpassBeginInfo *    pSubpassBeginInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdBeginRenderPass2KHR( commandBuffer, pRenderPassBegin, pSubpassBeginInfo );
-    }
-
-    void vkCmdNextSubpass2KHR( VkCommandBuffer            commandBuffer,
-                               const VkSubpassBeginInfo * pSubpassBeginInfo,
-                               const VkSubpassEndInfo *   pSubpassEndInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdNextSubpass2KHR( commandBuffer, pSubpassBeginInfo, pSubpassEndInfo );
-    }
-
-    void vkCmdEndRenderPass2KHR( VkCommandBuffer commandBuffer, const VkSubpassEndInfo * pSubpassEndInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdEndRenderPass2KHR( commandBuffer, pSubpassEndInfo );
-    }
-
-    //=== VK_KHR_shared_presentable_image ===
-
-    VkResult vkGetSwapchainStatusKHR( VkDevice device, VkSwapchainKHR swapchain ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetSwapchainStatusKHR( device, swapchain );
-    }
-
-    //=== VK_KHR_external_fence_capabilities ===
-
-    void vkGetPhysicalDeviceExternalFencePropertiesKHR( VkPhysicalDevice                          physicalDevice,
-                                                        const VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo,
-                                                        VkExternalFenceProperties *               pExternalFenceProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceExternalFencePropertiesKHR( physicalDevice, pExternalFenceInfo, pExternalFenceProperties );
-    }
-
-#  if defined( VK_USE_PLATFORM_WIN32_KHR )
-    //=== VK_KHR_external_fence_win32 ===
-
-    VkResult vkImportFenceWin32HandleKHR( VkDevice device, const VkImportFenceWin32HandleInfoKHR * pImportFenceWin32HandleInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkImportFenceWin32HandleKHR( device, pImportFenceWin32HandleInfo );
-    }
-
-    VkResult vkGetFenceWin32HandleKHR( VkDevice device, const VkFenceGetWin32HandleInfoKHR * pGetWin32HandleInfo, HANDLE * pHandle ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetFenceWin32HandleKHR( device, pGetWin32HandleInfo, pHandle );
-    }
-#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-    //=== VK_KHR_external_fence_fd ===
-
-    VkResult vkImportFenceFdKHR( VkDevice device, const VkImportFenceFdInfoKHR * pImportFenceFdInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkImportFenceFdKHR( device, pImportFenceFdInfo );
-    }
-
-    VkResult vkGetFenceFdKHR( VkDevice device, const VkFenceGetFdInfoKHR * pGetFdInfo, int * pFd ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetFenceFdKHR( device, pGetFdInfo, pFd );
-    }
-
-    //=== VK_KHR_performance_query ===
-
-    VkResult
-      vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( VkPhysicalDevice                     physicalDevice,
-                                                                       uint32_t                             queueFamilyIndex,
-                                                                       uint32_t *                           pCounterCount,
-                                                                       VkPerformanceCounterKHR *            pCounters,
-                                                                       VkPerformanceCounterDescriptionKHR * pCounterDescriptions ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
-        physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions );
-    }
-
-    void vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( VkPhysicalDevice                            physicalDevice,
-                                                                  const VkQueryPoolPerformanceCreateInfoKHR * pPerformanceQueryCreateInfo,
-                                                                  uint32_t *                                  pNumPasses ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( physicalDevice, pPerformanceQueryCreateInfo, pNumPasses );
-    }
-
-    VkResult vkAcquireProfilingLockKHR( VkDevice device, const VkAcquireProfilingLockInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkAcquireProfilingLockKHR( device, pInfo );
-    }
-
-    void vkReleaseProfilingLockKHR( VkDevice device ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkReleaseProfilingLockKHR( device );
-    }
-
-    //=== VK_KHR_get_surface_capabilities2 ===
-
-    VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR( VkPhysicalDevice                        physicalDevice,
-                                                         const VkPhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
-                                                         VkSurfaceCapabilities2KHR *             pSurfaceCapabilities ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceSurfaceCapabilities2KHR( physicalDevice, pSurfaceInfo, pSurfaceCapabilities );
-    }
-
-    VkResult vkGetPhysicalDeviceSurfaceFormats2KHR( VkPhysicalDevice                        physicalDevice,
-                                                    const VkPhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
-                                                    uint32_t *                              pSurfaceFormatCount,
-                                                    VkSurfaceFormat2KHR *                   pSurfaceFormats ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceSurfaceFormats2KHR( physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats );
-    }
-
-    //=== VK_KHR_get_display_properties2 ===
-
-    VkResult vkGetPhysicalDeviceDisplayProperties2KHR( VkPhysicalDevice          physicalDevice,
-                                                       uint32_t *                pPropertyCount,
-                                                       VkDisplayProperties2KHR * pProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceDisplayProperties2KHR( physicalDevice, pPropertyCount, pProperties );
-    }
-
-    VkResult vkGetPhysicalDeviceDisplayPlaneProperties2KHR( VkPhysicalDevice               physicalDevice,
-                                                            uint32_t *                     pPropertyCount,
-                                                            VkDisplayPlaneProperties2KHR * pProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceDisplayPlaneProperties2KHR( physicalDevice, pPropertyCount, pProperties );
-    }
-
-    VkResult vkGetDisplayModeProperties2KHR( VkPhysicalDevice              physicalDevice,
-                                             VkDisplayKHR                  display,
-                                             uint32_t *                    pPropertyCount,
-                                             VkDisplayModeProperties2KHR * pProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetDisplayModeProperties2KHR( physicalDevice, display, pPropertyCount, pProperties );
-    }
-
-    VkResult vkGetDisplayPlaneCapabilities2KHR( VkPhysicalDevice                 physicalDevice,
-                                                const VkDisplayPlaneInfo2KHR *   pDisplayPlaneInfo,
-                                                VkDisplayPlaneCapabilities2KHR * pCapabilities ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetDisplayPlaneCapabilities2KHR( physicalDevice, pDisplayPlaneInfo, pCapabilities );
-    }
-
-#  if defined( VK_USE_PLATFORM_IOS_MVK )
-    //=== VK_MVK_ios_surface ===
-
-    VkResult vkCreateIOSSurfaceMVK( VkInstance                        instance,
-                                    const VkIOSSurfaceCreateInfoMVK * pCreateInfo,
-                                    const VkAllocationCallbacks *     pAllocator,
-                                    VkSurfaceKHR *                    pSurface ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateIOSSurfaceMVK( instance, pCreateInfo, pAllocator, pSurface );
-    }
-#  endif /*VK_USE_PLATFORM_IOS_MVK*/
-
-#  if defined( VK_USE_PLATFORM_MACOS_MVK )
-    //=== VK_MVK_macos_surface ===
-
-    VkResult vkCreateMacOSSurfaceMVK( VkInstance                          instance,
-                                      const VkMacOSSurfaceCreateInfoMVK * pCreateInfo,
-                                      const VkAllocationCallbacks *       pAllocator,
-                                      VkSurfaceKHR *                      pSurface ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateMacOSSurfaceMVK( instance, pCreateInfo, pAllocator, pSurface );
-    }
-#  endif /*VK_USE_PLATFORM_MACOS_MVK*/
-
-    //=== VK_EXT_debug_utils ===
-
-    VkResult vkSetDebugUtilsObjectNameEXT( VkDevice device, const VkDebugUtilsObjectNameInfoEXT * pNameInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkSetDebugUtilsObjectNameEXT( device, pNameInfo );
-    }
-
-    VkResult vkSetDebugUtilsObjectTagEXT( VkDevice device, const VkDebugUtilsObjectTagInfoEXT * pTagInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkSetDebugUtilsObjectTagEXT( device, pTagInfo );
-    }
-
-    void vkQueueBeginDebugUtilsLabelEXT( VkQueue queue, const VkDebugUtilsLabelEXT * pLabelInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkQueueBeginDebugUtilsLabelEXT( queue, pLabelInfo );
-    }
-
-    void vkQueueEndDebugUtilsLabelEXT( VkQueue queue ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkQueueEndDebugUtilsLabelEXT( queue );
-    }
-
-    void vkQueueInsertDebugUtilsLabelEXT( VkQueue queue, const VkDebugUtilsLabelEXT * pLabelInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkQueueInsertDebugUtilsLabelEXT( queue, pLabelInfo );
-    }
-
-    void vkCmdBeginDebugUtilsLabelEXT( VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT * pLabelInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdBeginDebugUtilsLabelEXT( commandBuffer, pLabelInfo );
-    }
-
-    void vkCmdEndDebugUtilsLabelEXT( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdEndDebugUtilsLabelEXT( commandBuffer );
-    }
-
-    void vkCmdInsertDebugUtilsLabelEXT( VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT * pLabelInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdInsertDebugUtilsLabelEXT( commandBuffer, pLabelInfo );
-    }
-
-    VkResult vkCreateDebugUtilsMessengerEXT( VkInstance                                 instance,
-                                             const VkDebugUtilsMessengerCreateInfoEXT * pCreateInfo,
-                                             const VkAllocationCallbacks *              pAllocator,
-                                             VkDebugUtilsMessengerEXT *                 pMessenger ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateDebugUtilsMessengerEXT( instance, pCreateInfo, pAllocator, pMessenger );
-    }
-
-    void vkDestroyDebugUtilsMessengerEXT( VkInstance                    instance,
-                                          VkDebugUtilsMessengerEXT      messenger,
-                                          const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkDestroyDebugUtilsMessengerEXT( instance, messenger, pAllocator );
-    }
-
-    void vkSubmitDebugUtilsMessageEXT( VkInstance                                   instance,
-                                       VkDebugUtilsMessageSeverityFlagBitsEXT       messageSeverity,
-                                       VkDebugUtilsMessageTypeFlagsEXT              messageTypes,
-                                       const VkDebugUtilsMessengerCallbackDataEXT * pCallbackData ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkSubmitDebugUtilsMessageEXT( instance, messageSeverity, messageTypes, pCallbackData );
-    }
-
-#  if defined( VK_USE_PLATFORM_ANDROID_KHR )
-    //=== VK_ANDROID_external_memory_android_hardware_buffer ===
-
-    VkResult vkGetAndroidHardwareBufferPropertiesANDROID( VkDevice                                   device,
-                                                          const struct AHardwareBuffer *             buffer,
-                                                          VkAndroidHardwareBufferPropertiesANDROID * pProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetAndroidHardwareBufferPropertiesANDROID( device, buffer, pProperties );
-    }
-
-    VkResult vkGetMemoryAndroidHardwareBufferANDROID( VkDevice                                            device,
-                                                      const VkMemoryGetAndroidHardwareBufferInfoANDROID * pInfo,
-                                                      struct AHardwareBuffer **                           pBuffer ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetMemoryAndroidHardwareBufferANDROID( device, pInfo, pBuffer );
-    }
-#  endif /*VK_USE_PLATFORM_ANDROID_KHR*/
-
-#  if defined( VK_ENABLE_BETA_EXTENSIONS )
-    //=== VK_AMDX_shader_enqueue ===
-
-    VkResult vkCreateExecutionGraphPipelinesAMDX( VkDevice                                       device,
-                                                  VkPipelineCache                                pipelineCache,
-                                                  uint32_t                                       createInfoCount,
-                                                  const VkExecutionGraphPipelineCreateInfoAMDX * pCreateInfos,
-                                                  const VkAllocationCallbacks *                  pAllocator,
-                                                  VkPipeline *                                   pPipelines ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateExecutionGraphPipelinesAMDX( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines );
-    }
-
-    VkResult vkGetExecutionGraphPipelineScratchSizeAMDX( VkDevice                                  device,
-                                                         VkPipeline                                executionGraph,
-                                                         VkExecutionGraphPipelineScratchSizeAMDX * pSizeInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetExecutionGraphPipelineScratchSizeAMDX( device, executionGraph, pSizeInfo );
-    }
-
-    VkResult vkGetExecutionGraphPipelineNodeIndexAMDX( VkDevice                                        device,
-                                                       VkPipeline                                      executionGraph,
-                                                       const VkPipelineShaderStageNodeCreateInfoAMDX * pNodeInfo,
-                                                       uint32_t *                                      pNodeIndex ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetExecutionGraphPipelineNodeIndexAMDX( device, executionGraph, pNodeInfo, pNodeIndex );
-    }
-
-    void vkCmdInitializeGraphScratchMemoryAMDX( VkCommandBuffer commandBuffer,
-                                                VkPipeline      executionGraph,
-                                                VkDeviceAddress scratch,
-                                                VkDeviceSize    scratchSize ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdInitializeGraphScratchMemoryAMDX( commandBuffer, executionGraph, scratch, scratchSize );
-    }
-
-    void vkCmdDispatchGraphAMDX( VkCommandBuffer                      commandBuffer,
-                                 VkDeviceAddress                      scratch,
-                                 VkDeviceSize                         scratchSize,
-                                 const VkDispatchGraphCountInfoAMDX * pCountInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdDispatchGraphAMDX( commandBuffer, scratch, scratchSize, pCountInfo );
-    }
-
-    void vkCmdDispatchGraphIndirectAMDX( VkCommandBuffer                      commandBuffer,
-                                         VkDeviceAddress                      scratch,
-                                         VkDeviceSize                         scratchSize,
-                                         const VkDispatchGraphCountInfoAMDX * pCountInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdDispatchGraphIndirectAMDX( commandBuffer, scratch, scratchSize, pCountInfo );
-    }
-
-    void vkCmdDispatchGraphIndirectCountAMDX( VkCommandBuffer commandBuffer,
-                                              VkDeviceAddress scratch,
-                                              VkDeviceSize    scratchSize,
-                                              VkDeviceAddress countInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdDispatchGraphIndirectCountAMDX( commandBuffer, scratch, scratchSize, countInfo );
-    }
-#  endif /*VK_ENABLE_BETA_EXTENSIONS*/
-
-    //=== VK_EXT_sample_locations ===
-
-    void vkCmdSetSampleLocationsEXT( VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT * pSampleLocationsInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetSampleLocationsEXT( commandBuffer, pSampleLocationsInfo );
-    }
-
-    void vkGetPhysicalDeviceMultisamplePropertiesEXT( VkPhysicalDevice             physicalDevice,
-                                                      VkSampleCountFlagBits        samples,
-                                                      VkMultisamplePropertiesEXT * pMultisampleProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceMultisamplePropertiesEXT( physicalDevice, samples, pMultisampleProperties );
-    }
-
-    //=== VK_KHR_get_memory_requirements2 ===
-
-    void vkGetImageMemoryRequirements2KHR( VkDevice                               device,
-                                           const VkImageMemoryRequirementsInfo2 * pInfo,
-                                           VkMemoryRequirements2 *                pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetImageMemoryRequirements2KHR( device, pInfo, pMemoryRequirements );
-    }
-
-    void vkGetBufferMemoryRequirements2KHR( VkDevice                                device,
-                                            const VkBufferMemoryRequirementsInfo2 * pInfo,
-                                            VkMemoryRequirements2 *                 pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetBufferMemoryRequirements2KHR( device, pInfo, pMemoryRequirements );
-    }
-
-    void vkGetImageSparseMemoryRequirements2KHR( VkDevice                                     device,
-                                                 const VkImageSparseMemoryRequirementsInfo2 * pInfo,
-                                                 uint32_t *                                   pSparseMemoryRequirementCount,
-                                                 VkSparseImageMemoryRequirements2 *           pSparseMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetImageSparseMemoryRequirements2KHR( device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements );
-    }
-
-    //=== VK_KHR_acceleration_structure ===
-
-    VkResult vkCreateAccelerationStructureKHR( VkDevice                                     device,
-                                               const VkAccelerationStructureCreateInfoKHR * pCreateInfo,
-                                               const VkAllocationCallbacks *                pAllocator,
-                                               VkAccelerationStructureKHR *                 pAccelerationStructure ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateAccelerationStructureKHR( device, pCreateInfo, pAllocator, pAccelerationStructure );
-    }
-
-    void vkDestroyAccelerationStructureKHR( VkDevice                      device,
-                                            VkAccelerationStructureKHR    accelerationStructure,
-                                            const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkDestroyAccelerationStructureKHR( device, accelerationStructure, pAllocator );
-    }
-
-    void vkCmdBuildAccelerationStructuresKHR( VkCommandBuffer                                          commandBuffer,
-                                              uint32_t                                                 infoCount,
-                                              const VkAccelerationStructureBuildGeometryInfoKHR *      pInfos,
-                                              const VkAccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdBuildAccelerationStructuresKHR( commandBuffer, infoCount, pInfos, ppBuildRangeInfos );
-    }
-
-    void vkCmdBuildAccelerationStructuresIndirectKHR( VkCommandBuffer                                     commandBuffer,
-                                                      uint32_t                                            infoCount,
-                                                      const VkAccelerationStructureBuildGeometryInfoKHR * pInfos,
-                                                      const VkDeviceAddress *                             pIndirectDeviceAddresses,
-                                                      const uint32_t *                                    pIndirectStrides,
-                                                      const uint32_t * const *                            ppMaxPrimitiveCounts ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdBuildAccelerationStructuresIndirectKHR(
-        commandBuffer, infoCount, pInfos, pIndirectDeviceAddresses, pIndirectStrides, ppMaxPrimitiveCounts );
-    }
-
-    VkResult vkBuildAccelerationStructuresKHR( VkDevice                                                 device,
-                                               VkDeferredOperationKHR                                   deferredOperation,
-                                               uint32_t                                                 infoCount,
-                                               const VkAccelerationStructureBuildGeometryInfoKHR *      pInfos,
-                                               const VkAccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkBuildAccelerationStructuresKHR( device, deferredOperation, infoCount, pInfos, ppBuildRangeInfos );
-    }
-
-    VkResult vkCopyAccelerationStructureKHR( VkDevice                                   device,
-                                             VkDeferredOperationKHR                     deferredOperation,
-                                             const VkCopyAccelerationStructureInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCopyAccelerationStructureKHR( device, deferredOperation, pInfo );
-    }
-
-    VkResult vkCopyAccelerationStructureToMemoryKHR( VkDevice                                           device,
-                                                     VkDeferredOperationKHR                             deferredOperation,
-                                                     const VkCopyAccelerationStructureToMemoryInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCopyAccelerationStructureToMemoryKHR( device, deferredOperation, pInfo );
-    }
-
-    VkResult vkCopyMemoryToAccelerationStructureKHR( VkDevice                                           device,
-                                                     VkDeferredOperationKHR                             deferredOperation,
-                                                     const VkCopyMemoryToAccelerationStructureInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCopyMemoryToAccelerationStructureKHR( device, deferredOperation, pInfo );
-    }
-
-    VkResult vkWriteAccelerationStructuresPropertiesKHR( VkDevice                           device,
-                                                         uint32_t                           accelerationStructureCount,
-                                                         const VkAccelerationStructureKHR * pAccelerationStructures,
-                                                         VkQueryType                        queryType,
-                                                         size_t                             dataSize,
-                                                         void *                             pData,
-                                                         size_t                             stride ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkWriteAccelerationStructuresPropertiesKHR( device, accelerationStructureCount, pAccelerationStructures, queryType, dataSize, pData, stride );
-    }
-
-    void vkCmdCopyAccelerationStructureKHR( VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdCopyAccelerationStructureKHR( commandBuffer, pInfo );
-    }
-
-    void vkCmdCopyAccelerationStructureToMemoryKHR( VkCommandBuffer                                    commandBuffer,
-                                                    const VkCopyAccelerationStructureToMemoryInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdCopyAccelerationStructureToMemoryKHR( commandBuffer, pInfo );
-    }
-
-    void vkCmdCopyMemoryToAccelerationStructureKHR( VkCommandBuffer                                    commandBuffer,
-                                                    const VkCopyMemoryToAccelerationStructureInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdCopyMemoryToAccelerationStructureKHR( commandBuffer, pInfo );
-    }
-
-    VkDeviceAddress vkGetAccelerationStructureDeviceAddressKHR( VkDevice                                            device,
-                                                                const VkAccelerationStructureDeviceAddressInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetAccelerationStructureDeviceAddressKHR( device, pInfo );
-    }
-
-    void vkCmdWriteAccelerationStructuresPropertiesKHR( VkCommandBuffer                    commandBuffer,
-                                                        uint32_t                           accelerationStructureCount,
-                                                        const VkAccelerationStructureKHR * pAccelerationStructures,
-                                                        VkQueryType                        queryType,
-                                                        VkQueryPool                        queryPool,
-                                                        uint32_t                           firstQuery ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdWriteAccelerationStructuresPropertiesKHR(
-        commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery );
-    }
-
-    void vkGetDeviceAccelerationStructureCompatibilityKHR( VkDevice                                      device,
-                                                           const VkAccelerationStructureVersionInfoKHR * pVersionInfo,
-                                                           VkAccelerationStructureCompatibilityKHR *     pCompatibility ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetDeviceAccelerationStructureCompatibilityKHR( device, pVersionInfo, pCompatibility );
-    }
-
-    void vkGetAccelerationStructureBuildSizesKHR( VkDevice                                            device,
-                                                  VkAccelerationStructureBuildTypeKHR                 buildType,
-                                                  const VkAccelerationStructureBuildGeometryInfoKHR * pBuildInfo,
-                                                  const uint32_t *                                    pMaxPrimitiveCounts,
-                                                  VkAccelerationStructureBuildSizesInfoKHR *          pSizeInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetAccelerationStructureBuildSizesKHR( device, buildType, pBuildInfo, pMaxPrimitiveCounts, pSizeInfo );
-    }
-
-    //=== VK_KHR_ray_tracing_pipeline ===
-
-    void vkCmdTraceRaysKHR( VkCommandBuffer                         commandBuffer,
-                            const VkStridedDeviceAddressRegionKHR * pRaygenShaderBindingTable,
-                            const VkStridedDeviceAddressRegionKHR * pMissShaderBindingTable,
-                            const VkStridedDeviceAddressRegionKHR * pHitShaderBindingTable,
-                            const VkStridedDeviceAddressRegionKHR * pCallableShaderBindingTable,
-                            uint32_t                                width,
-                            uint32_t                                height,
-                            uint32_t                                depth ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdTraceRaysKHR(
-        commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, width, height, depth );
-    }
-
-    VkResult vkCreateRayTracingPipelinesKHR( VkDevice                                  device,
-                                             VkDeferredOperationKHR                    deferredOperation,
-                                             VkPipelineCache                           pipelineCache,
-                                             uint32_t                                  createInfoCount,
-                                             const VkRayTracingPipelineCreateInfoKHR * pCreateInfos,
-                                             const VkAllocationCallbacks *             pAllocator,
-                                             VkPipeline *                              pPipelines ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateRayTracingPipelinesKHR( device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines );
-    }
-
-    VkResult vkGetRayTracingShaderGroupHandlesKHR(
-      VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void * pData ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetRayTracingShaderGroupHandlesKHR( device, pipeline, firstGroup, groupCount, dataSize, pData );
-    }
-
-    VkResult vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(
-      VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void * pData ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( device, pipeline, firstGroup, groupCount, dataSize, pData );
-    }
-
-    void vkCmdTraceRaysIndirectKHR( VkCommandBuffer                         commandBuffer,
-                                    const VkStridedDeviceAddressRegionKHR * pRaygenShaderBindingTable,
-                                    const VkStridedDeviceAddressRegionKHR * pMissShaderBindingTable,
-                                    const VkStridedDeviceAddressRegionKHR * pHitShaderBindingTable,
-                                    const VkStridedDeviceAddressRegionKHR * pCallableShaderBindingTable,
-                                    VkDeviceAddress                         indirectDeviceAddress ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdTraceRaysIndirectKHR(
-        commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, indirectDeviceAddress );
-    }
-
-    VkDeviceSize vkGetRayTracingShaderGroupStackSizeKHR( VkDevice               device,
-                                                         VkPipeline             pipeline,
-                                                         uint32_t               group,
-                                                         VkShaderGroupShaderKHR groupShader ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetRayTracingShaderGroupStackSizeKHR( device, pipeline, group, groupShader );
-    }
-
-    void vkCmdSetRayTracingPipelineStackSizeKHR( VkCommandBuffer commandBuffer, uint32_t pipelineStackSize ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetRayTracingPipelineStackSizeKHR( commandBuffer, pipelineStackSize );
-    }
-
-    //=== VK_KHR_sampler_ycbcr_conversion ===
-
-    VkResult vkCreateSamplerYcbcrConversionKHR( VkDevice                                   device,
-                                                const VkSamplerYcbcrConversionCreateInfo * pCreateInfo,
-                                                const VkAllocationCallbacks *              pAllocator,
-                                                VkSamplerYcbcrConversion *                 pYcbcrConversion ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateSamplerYcbcrConversionKHR( device, pCreateInfo, pAllocator, pYcbcrConversion );
-    }
-
-    void vkDestroySamplerYcbcrConversionKHR( VkDevice                      device,
-                                             VkSamplerYcbcrConversion      ycbcrConversion,
-                                             const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkDestroySamplerYcbcrConversionKHR( device, ycbcrConversion, pAllocator );
-    }
-
-    //=== VK_KHR_bind_memory2 ===
-
-    VkResult vkBindBufferMemory2KHR( VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo * pBindInfos ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkBindBufferMemory2KHR( device, bindInfoCount, pBindInfos );
-    }
-
-    VkResult vkBindImageMemory2KHR( VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo * pBindInfos ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkBindImageMemory2KHR( device, bindInfoCount, pBindInfos );
-    }
-
-    //=== VK_EXT_image_drm_format_modifier ===
-
-    VkResult
-      vkGetImageDrmFormatModifierPropertiesEXT( VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT * pProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetImageDrmFormatModifierPropertiesEXT( device, image, pProperties );
-    }
-
-    //=== VK_EXT_validation_cache ===
-
-    VkResult vkCreateValidationCacheEXT( VkDevice                               device,
-                                         const VkValidationCacheCreateInfoEXT * pCreateInfo,
-                                         const VkAllocationCallbacks *          pAllocator,
-                                         VkValidationCacheEXT *                 pValidationCache ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateValidationCacheEXT( device, pCreateInfo, pAllocator, pValidationCache );
-    }
-
-    void
-      vkDestroyValidationCacheEXT( VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkDestroyValidationCacheEXT( device, validationCache, pAllocator );
-    }
-
-    VkResult vkMergeValidationCachesEXT( VkDevice                     device,
-                                         VkValidationCacheEXT         dstCache,
-                                         uint32_t                     srcCacheCount,
-                                         const VkValidationCacheEXT * pSrcCaches ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkMergeValidationCachesEXT( device, dstCache, srcCacheCount, pSrcCaches );
-    }
-
-    VkResult vkGetValidationCacheDataEXT( VkDevice device, VkValidationCacheEXT validationCache, size_t * pDataSize, void * pData ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetValidationCacheDataEXT( device, validationCache, pDataSize, pData );
-    }
-
-    //=== VK_NV_shading_rate_image ===
-
-    void vkCmdBindShadingRateImageNV( VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdBindShadingRateImageNV( commandBuffer, imageView, imageLayout );
-    }
-
-    void vkCmdSetViewportShadingRatePaletteNV( VkCommandBuffer                commandBuffer,
-                                               uint32_t                       firstViewport,
-                                               uint32_t                       viewportCount,
-                                               const VkShadingRatePaletteNV * pShadingRatePalettes ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetViewportShadingRatePaletteNV( commandBuffer, firstViewport, viewportCount, pShadingRatePalettes );
-    }
-
-    void vkCmdSetCoarseSampleOrderNV( VkCommandBuffer                     commandBuffer,
-                                      VkCoarseSampleOrderTypeNV           sampleOrderType,
-                                      uint32_t                            customSampleOrderCount,
-                                      const VkCoarseSampleOrderCustomNV * pCustomSampleOrders ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetCoarseSampleOrderNV( commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders );
-    }
-
-    //=== VK_NV_ray_tracing ===
-
-    VkResult vkCreateAccelerationStructureNV( VkDevice                                    device,
-                                              const VkAccelerationStructureCreateInfoNV * pCreateInfo,
-                                              const VkAllocationCallbacks *               pAllocator,
-                                              VkAccelerationStructureNV *                 pAccelerationStructure ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateAccelerationStructureNV( device, pCreateInfo, pAllocator, pAccelerationStructure );
-    }
-
-    void vkDestroyAccelerationStructureNV( VkDevice                      device,
-                                           VkAccelerationStructureNV     accelerationStructure,
-                                           const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkDestroyAccelerationStructureNV( device, accelerationStructure, pAllocator );
-    }
-
-    void vkGetAccelerationStructureMemoryRequirementsNV( VkDevice                                                device,
-                                                         const VkAccelerationStructureMemoryRequirementsInfoNV * pInfo,
-                                                         VkMemoryRequirements2KHR *                              pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetAccelerationStructureMemoryRequirementsNV( device, pInfo, pMemoryRequirements );
-    }
-
-    VkResult vkBindAccelerationStructureMemoryNV( VkDevice                                        device,
-                                                  uint32_t                                        bindInfoCount,
-                                                  const VkBindAccelerationStructureMemoryInfoNV * pBindInfos ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkBindAccelerationStructureMemoryNV( device, bindInfoCount, pBindInfos );
-    }
-
-    void vkCmdBuildAccelerationStructureNV( VkCommandBuffer                       commandBuffer,
-                                            const VkAccelerationStructureInfoNV * pInfo,
-                                            VkBuffer                              instanceData,
-                                            VkDeviceSize                          instanceOffset,
-                                            VkBool32                              update,
-                                            VkAccelerationStructureNV             dst,
-                                            VkAccelerationStructureNV             src,
-                                            VkBuffer                              scratch,
-                                            VkDeviceSize                          scratchOffset ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdBuildAccelerationStructureNV( commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset );
-    }
-
-    void vkCmdCopyAccelerationStructureNV( VkCommandBuffer                    commandBuffer,
-                                           VkAccelerationStructureNV          dst,
-                                           VkAccelerationStructureNV          src,
-                                           VkCopyAccelerationStructureModeKHR mode ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdCopyAccelerationStructureNV( commandBuffer, dst, src, mode );
-    }
-
-    void vkCmdTraceRaysNV( VkCommandBuffer commandBuffer,
-                           VkBuffer        raygenShaderBindingTableBuffer,
-                           VkDeviceSize    raygenShaderBindingOffset,
-                           VkBuffer        missShaderBindingTableBuffer,
-                           VkDeviceSize    missShaderBindingOffset,
-                           VkDeviceSize    missShaderBindingStride,
-                           VkBuffer        hitShaderBindingTableBuffer,
-                           VkDeviceSize    hitShaderBindingOffset,
-                           VkDeviceSize    hitShaderBindingStride,
-                           VkBuffer        callableShaderBindingTableBuffer,
-                           VkDeviceSize    callableShaderBindingOffset,
-                           VkDeviceSize    callableShaderBindingStride,
-                           uint32_t        width,
-                           uint32_t        height,
-                           uint32_t        depth ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdTraceRaysNV( commandBuffer,
-                                 raygenShaderBindingTableBuffer,
-                                 raygenShaderBindingOffset,
-                                 missShaderBindingTableBuffer,
-                                 missShaderBindingOffset,
-                                 missShaderBindingStride,
-                                 hitShaderBindingTableBuffer,
-                                 hitShaderBindingOffset,
-                                 hitShaderBindingStride,
-                                 callableShaderBindingTableBuffer,
-                                 callableShaderBindingOffset,
-                                 callableShaderBindingStride,
-                                 width,
-                                 height,
-                                 depth );
-    }
-
-    VkResult vkCreateRayTracingPipelinesNV( VkDevice                                 device,
-                                            VkPipelineCache                          pipelineCache,
-                                            uint32_t                                 createInfoCount,
-                                            const VkRayTracingPipelineCreateInfoNV * pCreateInfos,
-                                            const VkAllocationCallbacks *            pAllocator,
-                                            VkPipeline *                             pPipelines ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateRayTracingPipelinesNV( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines );
-    }
-
-    VkResult vkGetRayTracingShaderGroupHandlesNV(
-      VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void * pData ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetRayTracingShaderGroupHandlesNV( device, pipeline, firstGroup, groupCount, dataSize, pData );
-    }
-
-    VkResult vkGetAccelerationStructureHandleNV( VkDevice                  device,
-                                                 VkAccelerationStructureNV accelerationStructure,
-                                                 size_t                    dataSize,
-                                                 void *                    pData ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetAccelerationStructureHandleNV( device, accelerationStructure, dataSize, pData );
-    }
-
-    void vkCmdWriteAccelerationStructuresPropertiesNV( VkCommandBuffer                   commandBuffer,
-                                                       uint32_t                          accelerationStructureCount,
-                                                       const VkAccelerationStructureNV * pAccelerationStructures,
-                                                       VkQueryType                       queryType,
-                                                       VkQueryPool                       queryPool,
-                                                       uint32_t                          firstQuery ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdWriteAccelerationStructuresPropertiesNV(
-        commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery );
-    }
-
-    VkResult vkCompileDeferredNV( VkDevice device, VkPipeline pipeline, uint32_t shader ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCompileDeferredNV( device, pipeline, shader );
-    }
-
-    //=== VK_KHR_maintenance3 ===
-
-    void vkGetDescriptorSetLayoutSupportKHR( VkDevice                                device,
-                                             const VkDescriptorSetLayoutCreateInfo * pCreateInfo,
-                                             VkDescriptorSetLayoutSupport *          pSupport ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetDescriptorSetLayoutSupportKHR( device, pCreateInfo, pSupport );
-    }
-
-    //=== VK_KHR_draw_indirect_count ===
-
-    void vkCmdDrawIndirectCountKHR( VkCommandBuffer commandBuffer,
-                                    VkBuffer        buffer,
-                                    VkDeviceSize    offset,
-                                    VkBuffer        countBuffer,
-                                    VkDeviceSize    countBufferOffset,
-                                    uint32_t        maxDrawCount,
-                                    uint32_t        stride ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdDrawIndirectCountKHR( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
-    }
-
-    void vkCmdDrawIndexedIndirectCountKHR( VkCommandBuffer commandBuffer,
-                                           VkBuffer        buffer,
-                                           VkDeviceSize    offset,
-                                           VkBuffer        countBuffer,
-                                           VkDeviceSize    countBufferOffset,
-                                           uint32_t        maxDrawCount,
-                                           uint32_t        stride ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdDrawIndexedIndirectCountKHR( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
-    }
-
-    //=== VK_EXT_external_memory_host ===
-
-    VkResult vkGetMemoryHostPointerPropertiesEXT( VkDevice                           device,
-                                                  VkExternalMemoryHandleTypeFlagBits handleType,
-                                                  const void *                       pHostPointer,
-                                                  VkMemoryHostPointerPropertiesEXT * pMemoryHostPointerProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetMemoryHostPointerPropertiesEXT( device, handleType, pHostPointer, pMemoryHostPointerProperties );
-    }
-
-    //=== VK_AMD_buffer_marker ===
-
-    void vkCmdWriteBufferMarkerAMD( VkCommandBuffer         commandBuffer,
-                                    VkPipelineStageFlagBits pipelineStage,
-                                    VkBuffer                dstBuffer,
-                                    VkDeviceSize            dstOffset,
-                                    uint32_t                marker ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdWriteBufferMarkerAMD( commandBuffer, pipelineStage, dstBuffer, dstOffset, marker );
-    }
-
-    void vkCmdWriteBufferMarker2AMD(
-      VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdWriteBufferMarker2AMD( commandBuffer, stage, dstBuffer, dstOffset, marker );
-    }
-
-    //=== VK_EXT_calibrated_timestamps ===
-
-    VkResult vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( VkPhysicalDevice  physicalDevice,
-                                                             uint32_t *        pTimeDomainCount,
-                                                             VkTimeDomainKHR * pTimeDomains ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( physicalDevice, pTimeDomainCount, pTimeDomains );
-    }
-
-    VkResult vkGetCalibratedTimestampsEXT( VkDevice                             device,
-                                           uint32_t                             timestampCount,
-                                           const VkCalibratedTimestampInfoKHR * pTimestampInfos,
-                                           uint64_t *                           pTimestamps,
-                                           uint64_t *                           pMaxDeviation ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetCalibratedTimestampsEXT( device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation );
-    }
-
-    //=== VK_NV_mesh_shader ===
-
-    void vkCmdDrawMeshTasksNV( VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdDrawMeshTasksNV( commandBuffer, taskCount, firstTask );
-    }
-
-    void vkCmdDrawMeshTasksIndirectNV( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride ) const
-      VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdDrawMeshTasksIndirectNV( commandBuffer, buffer, offset, drawCount, stride );
-    }
-
-    void vkCmdDrawMeshTasksIndirectCountNV( VkCommandBuffer commandBuffer,
-                                            VkBuffer        buffer,
-                                            VkDeviceSize    offset,
-                                            VkBuffer        countBuffer,
-                                            VkDeviceSize    countBufferOffset,
-                                            uint32_t        maxDrawCount,
-                                            uint32_t        stride ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdDrawMeshTasksIndirectCountNV( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
-    }
-
-    //=== VK_NV_scissor_exclusive ===
-
-    void vkCmdSetExclusiveScissorEnableNV( VkCommandBuffer  commandBuffer,
-                                           uint32_t         firstExclusiveScissor,
-                                           uint32_t         exclusiveScissorCount,
-                                           const VkBool32 * pExclusiveScissorEnables ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetExclusiveScissorEnableNV( commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissorEnables );
-    }
-
-    void vkCmdSetExclusiveScissorNV( VkCommandBuffer  commandBuffer,
-                                     uint32_t         firstExclusiveScissor,
-                                     uint32_t         exclusiveScissorCount,
-                                     const VkRect2D * pExclusiveScissors ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetExclusiveScissorNV( commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors );
-    }
-
-    //=== VK_NV_device_diagnostic_checkpoints ===
-
-    void vkCmdSetCheckpointNV( VkCommandBuffer commandBuffer, const void * pCheckpointMarker ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetCheckpointNV( commandBuffer, pCheckpointMarker );
-    }
-
-    void vkGetQueueCheckpointDataNV( VkQueue queue, uint32_t * pCheckpointDataCount, VkCheckpointDataNV * pCheckpointData ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetQueueCheckpointDataNV( queue, pCheckpointDataCount, pCheckpointData );
-    }
-
-    void vkGetQueueCheckpointData2NV( VkQueue queue, uint32_t * pCheckpointDataCount, VkCheckpointData2NV * pCheckpointData ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetQueueCheckpointData2NV( queue, pCheckpointDataCount, pCheckpointData );
-    }
-
-    //=== VK_KHR_timeline_semaphore ===
-
-    VkResult vkGetSemaphoreCounterValueKHR( VkDevice device, VkSemaphore semaphore, uint64_t * pValue ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetSemaphoreCounterValueKHR( device, semaphore, pValue );
-    }
-
-    VkResult vkWaitSemaphoresKHR( VkDevice device, const VkSemaphoreWaitInfo * pWaitInfo, uint64_t timeout ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkWaitSemaphoresKHR( device, pWaitInfo, timeout );
-    }
-
-    VkResult vkSignalSemaphoreKHR( VkDevice device, const VkSemaphoreSignalInfo * pSignalInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkSignalSemaphoreKHR( device, pSignalInfo );
-    }
-
-    //=== VK_INTEL_performance_query ===
-
-    VkResult vkInitializePerformanceApiINTEL( VkDevice device, const VkInitializePerformanceApiInfoINTEL * pInitializeInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkInitializePerformanceApiINTEL( device, pInitializeInfo );
-    }
-
-    void vkUninitializePerformanceApiINTEL( VkDevice device ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkUninitializePerformanceApiINTEL( device );
-    }
-
-    VkResult vkCmdSetPerformanceMarkerINTEL( VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL * pMarkerInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetPerformanceMarkerINTEL( commandBuffer, pMarkerInfo );
-    }
-
-    VkResult vkCmdSetPerformanceStreamMarkerINTEL( VkCommandBuffer                            commandBuffer,
-                                                   const VkPerformanceStreamMarkerInfoINTEL * pMarkerInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetPerformanceStreamMarkerINTEL( commandBuffer, pMarkerInfo );
-    }
-
-    VkResult vkCmdSetPerformanceOverrideINTEL( VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL * pOverrideInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetPerformanceOverrideINTEL( commandBuffer, pOverrideInfo );
-    }
-
-    VkResult vkAcquirePerformanceConfigurationINTEL( VkDevice                                           device,
-                                                     const VkPerformanceConfigurationAcquireInfoINTEL * pAcquireInfo,
-                                                     VkPerformanceConfigurationINTEL *                  pConfiguration ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkAcquirePerformanceConfigurationINTEL( device, pAcquireInfo, pConfiguration );
-    }
-
-    VkResult vkReleasePerformanceConfigurationINTEL( VkDevice device, VkPerformanceConfigurationINTEL configuration ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkReleasePerformanceConfigurationINTEL( device, configuration );
-    }
-
-    VkResult vkQueueSetPerformanceConfigurationINTEL( VkQueue queue, VkPerformanceConfigurationINTEL configuration ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkQueueSetPerformanceConfigurationINTEL( queue, configuration );
-    }
-
-    VkResult
-      vkGetPerformanceParameterINTEL( VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL * pValue ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPerformanceParameterINTEL( device, parameter, pValue );
-    }
-
-    //=== VK_AMD_display_native_hdr ===
-
-    void vkSetLocalDimmingAMD( VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkSetLocalDimmingAMD( device, swapChain, localDimmingEnable );
-    }
-
-#  if defined( VK_USE_PLATFORM_FUCHSIA )
-    //=== VK_FUCHSIA_imagepipe_surface ===
-
-    VkResult vkCreateImagePipeSurfaceFUCHSIA( VkInstance                                  instance,
-                                              const VkImagePipeSurfaceCreateInfoFUCHSIA * pCreateInfo,
-                                              const VkAllocationCallbacks *               pAllocator,
-                                              VkSurfaceKHR *                              pSurface ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateImagePipeSurfaceFUCHSIA( instance, pCreateInfo, pAllocator, pSurface );
-    }
-#  endif /*VK_USE_PLATFORM_FUCHSIA*/
-
-#  if defined( VK_USE_PLATFORM_METAL_EXT )
-    //=== VK_EXT_metal_surface ===
-
-    VkResult vkCreateMetalSurfaceEXT( VkInstance                          instance,
-                                      const VkMetalSurfaceCreateInfoEXT * pCreateInfo,
-                                      const VkAllocationCallbacks *       pAllocator,
-                                      VkSurfaceKHR *                      pSurface ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateMetalSurfaceEXT( instance, pCreateInfo, pAllocator, pSurface );
-    }
-#  endif /*VK_USE_PLATFORM_METAL_EXT*/
-
-    //=== VK_KHR_fragment_shading_rate ===
-
-    VkResult vkGetPhysicalDeviceFragmentShadingRatesKHR( VkPhysicalDevice                         physicalDevice,
-                                                         uint32_t *                               pFragmentShadingRateCount,
-                                                         VkPhysicalDeviceFragmentShadingRateKHR * pFragmentShadingRates ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceFragmentShadingRatesKHR( physicalDevice, pFragmentShadingRateCount, pFragmentShadingRates );
-    }
-
-    void vkCmdSetFragmentShadingRateKHR( VkCommandBuffer                          commandBuffer,
-                                         const VkExtent2D *                       pFragmentSize,
-                                         const VkFragmentShadingRateCombinerOpKHR combinerOps[2] ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetFragmentShadingRateKHR( commandBuffer, pFragmentSize, combinerOps );
-    }
-
-    //=== VK_KHR_dynamic_rendering_local_read ===
-
-    void vkCmdSetRenderingAttachmentLocationsKHR( VkCommandBuffer                              commandBuffer,
-                                                  const VkRenderingAttachmentLocationInfoKHR * pLocationInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetRenderingAttachmentLocationsKHR( commandBuffer, pLocationInfo );
-    }
-
-    void vkCmdSetRenderingInputAttachmentIndicesKHR( VkCommandBuffer                                commandBuffer,
-                                                     const VkRenderingInputAttachmentIndexInfoKHR * pInputAttachmentIndexInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetRenderingInputAttachmentIndicesKHR( commandBuffer, pInputAttachmentIndexInfo );
-    }
-
-    //=== VK_EXT_buffer_device_address ===
-
-    VkDeviceAddress vkGetBufferDeviceAddressEXT( VkDevice device, const VkBufferDeviceAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetBufferDeviceAddressEXT( device, pInfo );
-    }
-
-    //=== VK_EXT_tooling_info ===
-
-    VkResult vkGetPhysicalDeviceToolPropertiesEXT( VkPhysicalDevice                 physicalDevice,
-                                                   uint32_t *                       pToolCount,
-                                                   VkPhysicalDeviceToolProperties * pToolProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceToolPropertiesEXT( physicalDevice, pToolCount, pToolProperties );
-    }
-
-    //=== VK_KHR_present_wait ===
-
-    VkResult vkWaitForPresentKHR( VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkWaitForPresentKHR( device, swapchain, presentId, timeout );
-    }
-
-    //=== VK_NV_cooperative_matrix ===
-
-    VkResult vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( VkPhysicalDevice                  physicalDevice,
-                                                               uint32_t *                        pPropertyCount,
-                                                               VkCooperativeMatrixPropertiesNV * pProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( physicalDevice, pPropertyCount, pProperties );
-    }
-
-    //=== VK_NV_coverage_reduction_mode ===
-
-    VkResult vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
-      VkPhysicalDevice physicalDevice, uint32_t * pCombinationCount, VkFramebufferMixedSamplesCombinationNV * pCombinations ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( physicalDevice, pCombinationCount, pCombinations );
-    }
-
-#  if defined( VK_USE_PLATFORM_WIN32_KHR )
-    //=== VK_EXT_full_screen_exclusive ===
-
-    VkResult vkGetPhysicalDeviceSurfacePresentModes2EXT( VkPhysicalDevice                        physicalDevice,
-                                                         const VkPhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
-                                                         uint32_t *                              pPresentModeCount,
-                                                         VkPresentModeKHR *                      pPresentModes ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceSurfacePresentModes2EXT( physicalDevice, pSurfaceInfo, pPresentModeCount, pPresentModes );
-    }
-
-    VkResult vkAcquireFullScreenExclusiveModeEXT( VkDevice device, VkSwapchainKHR swapchain ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkAcquireFullScreenExclusiveModeEXT( device, swapchain );
-    }
-
-    VkResult vkReleaseFullScreenExclusiveModeEXT( VkDevice device, VkSwapchainKHR swapchain ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkReleaseFullScreenExclusiveModeEXT( device, swapchain );
-    }
-
-    VkResult vkGetDeviceGroupSurfacePresentModes2EXT( VkDevice                                device,
-                                                      const VkPhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
-                                                      VkDeviceGroupPresentModeFlagsKHR *      pModes ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetDeviceGroupSurfacePresentModes2EXT( device, pSurfaceInfo, pModes );
-    }
-#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-    //=== VK_EXT_headless_surface ===
-
-    VkResult vkCreateHeadlessSurfaceEXT( VkInstance                             instance,
-                                         const VkHeadlessSurfaceCreateInfoEXT * pCreateInfo,
-                                         const VkAllocationCallbacks *          pAllocator,
-                                         VkSurfaceKHR *                         pSurface ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateHeadlessSurfaceEXT( instance, pCreateInfo, pAllocator, pSurface );
-    }
-
-    //=== VK_KHR_buffer_device_address ===
-
-    VkDeviceAddress vkGetBufferDeviceAddressKHR( VkDevice device, const VkBufferDeviceAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetBufferDeviceAddressKHR( device, pInfo );
-    }
-
-    uint64_t vkGetBufferOpaqueCaptureAddressKHR( VkDevice device, const VkBufferDeviceAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetBufferOpaqueCaptureAddressKHR( device, pInfo );
-    }
-
-    uint64_t vkGetDeviceMemoryOpaqueCaptureAddressKHR( VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetDeviceMemoryOpaqueCaptureAddressKHR( device, pInfo );
-    }
-
-    //=== VK_EXT_line_rasterization ===
-
-    void vkCmdSetLineStippleEXT( VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetLineStippleEXT( commandBuffer, lineStippleFactor, lineStipplePattern );
-    }
-
-    //=== VK_EXT_host_query_reset ===
-
-    void vkResetQueryPoolEXT( VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkResetQueryPoolEXT( device, queryPool, firstQuery, queryCount );
-    }
-
-    //=== VK_EXT_extended_dynamic_state ===
-
-    void vkCmdSetCullModeEXT( VkCommandBuffer commandBuffer, VkCullModeFlags cullMode ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetCullModeEXT( commandBuffer, cullMode );
-    }
-
-    void vkCmdSetFrontFaceEXT( VkCommandBuffer commandBuffer, VkFrontFace frontFace ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetFrontFaceEXT( commandBuffer, frontFace );
-    }
-
-    void vkCmdSetPrimitiveTopologyEXT( VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetPrimitiveTopologyEXT( commandBuffer, primitiveTopology );
-    }
-
-    void vkCmdSetViewportWithCountEXT( VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport * pViewports ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetViewportWithCountEXT( commandBuffer, viewportCount, pViewports );
-    }
-
-    void vkCmdSetScissorWithCountEXT( VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D * pScissors ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetScissorWithCountEXT( commandBuffer, scissorCount, pScissors );
-    }
-
-    void vkCmdBindVertexBuffers2EXT( VkCommandBuffer      commandBuffer,
-                                     uint32_t             firstBinding,
-                                     uint32_t             bindingCount,
-                                     const VkBuffer *     pBuffers,
-                                     const VkDeviceSize * pOffsets,
-                                     const VkDeviceSize * pSizes,
-                                     const VkDeviceSize * pStrides ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdBindVertexBuffers2EXT( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides );
-    }
-
-    void vkCmdSetDepthTestEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthTestEnable ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetDepthTestEnableEXT( commandBuffer, depthTestEnable );
-    }
-
-    void vkCmdSetDepthWriteEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetDepthWriteEnableEXT( commandBuffer, depthWriteEnable );
-    }
-
-    void vkCmdSetDepthCompareOpEXT( VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetDepthCompareOpEXT( commandBuffer, depthCompareOp );
-    }
-
-    void vkCmdSetDepthBoundsTestEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetDepthBoundsTestEnableEXT( commandBuffer, depthBoundsTestEnable );
-    }
-
-    void vkCmdSetStencilTestEnableEXT( VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetStencilTestEnableEXT( commandBuffer, stencilTestEnable );
-    }
-
-    void vkCmdSetStencilOpEXT( VkCommandBuffer    commandBuffer,
-                               VkStencilFaceFlags faceMask,
-                               VkStencilOp        failOp,
-                               VkStencilOp        passOp,
-                               VkStencilOp        depthFailOp,
-                               VkCompareOp        compareOp ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetStencilOpEXT( commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp );
-    }
-
-    //=== VK_KHR_deferred_host_operations ===
-
-    VkResult vkCreateDeferredOperationKHR( VkDevice                      device,
-                                           const VkAllocationCallbacks * pAllocator,
-                                           VkDeferredOperationKHR *      pDeferredOperation ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateDeferredOperationKHR( device, pAllocator, pDeferredOperation );
-    }
-
-    void vkDestroyDeferredOperationKHR( VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkDestroyDeferredOperationKHR( device, operation, pAllocator );
-    }
-
-    uint32_t vkGetDeferredOperationMaxConcurrencyKHR( VkDevice device, VkDeferredOperationKHR operation ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetDeferredOperationMaxConcurrencyKHR( device, operation );
-    }
-
-    VkResult vkGetDeferredOperationResultKHR( VkDevice device, VkDeferredOperationKHR operation ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetDeferredOperationResultKHR( device, operation );
-    }
-
-    VkResult vkDeferredOperationJoinKHR( VkDevice device, VkDeferredOperationKHR operation ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkDeferredOperationJoinKHR( device, operation );
-    }
-
-    //=== VK_KHR_pipeline_executable_properties ===
-
-    VkResult vkGetPipelineExecutablePropertiesKHR( VkDevice                            device,
-                                                   const VkPipelineInfoKHR *           pPipelineInfo,
-                                                   uint32_t *                          pExecutableCount,
-                                                   VkPipelineExecutablePropertiesKHR * pProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPipelineExecutablePropertiesKHR( device, pPipelineInfo, pExecutableCount, pProperties );
-    }
-
-    VkResult vkGetPipelineExecutableStatisticsKHR( VkDevice                            device,
-                                                   const VkPipelineExecutableInfoKHR * pExecutableInfo,
-                                                   uint32_t *                          pStatisticCount,
-                                                   VkPipelineExecutableStatisticKHR *  pStatistics ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPipelineExecutableStatisticsKHR( device, pExecutableInfo, pStatisticCount, pStatistics );
-    }
-
-    VkResult
-      vkGetPipelineExecutableInternalRepresentationsKHR( VkDevice                                        device,
-                                                         const VkPipelineExecutableInfoKHR *             pExecutableInfo,
-                                                         uint32_t *                                      pInternalRepresentationCount,
-                                                         VkPipelineExecutableInternalRepresentationKHR * pInternalRepresentations ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPipelineExecutableInternalRepresentationsKHR( device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations );
-    }
-
-    //=== VK_EXT_host_image_copy ===
-
-    VkResult vkCopyMemoryToImageEXT( VkDevice device, const VkCopyMemoryToImageInfoEXT * pCopyMemoryToImageInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCopyMemoryToImageEXT( device, pCopyMemoryToImageInfo );
-    }
-
-    VkResult vkCopyImageToMemoryEXT( VkDevice device, const VkCopyImageToMemoryInfoEXT * pCopyImageToMemoryInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCopyImageToMemoryEXT( device, pCopyImageToMemoryInfo );
-    }
-
-    VkResult vkCopyImageToImageEXT( VkDevice device, const VkCopyImageToImageInfoEXT * pCopyImageToImageInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCopyImageToImageEXT( device, pCopyImageToImageInfo );
-    }
-
-    VkResult
-      vkTransitionImageLayoutEXT( VkDevice device, uint32_t transitionCount, const VkHostImageLayoutTransitionInfoEXT * pTransitions ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkTransitionImageLayoutEXT( device, transitionCount, pTransitions );
-    }
-
-    void vkGetImageSubresourceLayout2EXT( VkDevice                       device,
-                                          VkImage                        image,
-                                          const VkImageSubresource2KHR * pSubresource,
-                                          VkSubresourceLayout2KHR *      pLayout ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetImageSubresourceLayout2EXT( device, image, pSubresource, pLayout );
-    }
-
-    //=== VK_KHR_map_memory2 ===
-
-    VkResult vkMapMemory2KHR( VkDevice device, const VkMemoryMapInfoKHR * pMemoryMapInfo, void ** ppData ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkMapMemory2KHR( device, pMemoryMapInfo, ppData );
-    }
-
-    VkResult vkUnmapMemory2KHR( VkDevice device, const VkMemoryUnmapInfoKHR * pMemoryUnmapInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkUnmapMemory2KHR( device, pMemoryUnmapInfo );
-    }
-
-    //=== VK_EXT_swapchain_maintenance1 ===
-
-    VkResult vkReleaseSwapchainImagesEXT( VkDevice device, const VkReleaseSwapchainImagesInfoEXT * pReleaseInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkReleaseSwapchainImagesEXT( device, pReleaseInfo );
-    }
-
-    //=== VK_NV_device_generated_commands ===
-
-    void vkGetGeneratedCommandsMemoryRequirementsNV( VkDevice                                            device,
-                                                     const VkGeneratedCommandsMemoryRequirementsInfoNV * pInfo,
-                                                     VkMemoryRequirements2 *                             pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetGeneratedCommandsMemoryRequirementsNV( device, pInfo, pMemoryRequirements );
-    }
-
-    void vkCmdPreprocessGeneratedCommandsNV( VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV * pGeneratedCommandsInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdPreprocessGeneratedCommandsNV( commandBuffer, pGeneratedCommandsInfo );
-    }
-
-    void vkCmdExecuteGeneratedCommandsNV( VkCommandBuffer                   commandBuffer,
-                                          VkBool32                          isPreprocessed,
-                                          const VkGeneratedCommandsInfoNV * pGeneratedCommandsInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdExecuteGeneratedCommandsNV( commandBuffer, isPreprocessed, pGeneratedCommandsInfo );
-    }
-
-    void vkCmdBindPipelineShaderGroupNV( VkCommandBuffer     commandBuffer,
-                                         VkPipelineBindPoint pipelineBindPoint,
-                                         VkPipeline          pipeline,
-                                         uint32_t            groupIndex ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdBindPipelineShaderGroupNV( commandBuffer, pipelineBindPoint, pipeline, groupIndex );
-    }
-
-    VkResult vkCreateIndirectCommandsLayoutNV( VkDevice                                     device,
-                                               const VkIndirectCommandsLayoutCreateInfoNV * pCreateInfo,
-                                               const VkAllocationCallbacks *                pAllocator,
-                                               VkIndirectCommandsLayoutNV *                 pIndirectCommandsLayout ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateIndirectCommandsLayoutNV( device, pCreateInfo, pAllocator, pIndirectCommandsLayout );
-    }
-
-    void vkDestroyIndirectCommandsLayoutNV( VkDevice                      device,
-                                            VkIndirectCommandsLayoutNV    indirectCommandsLayout,
-                                            const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkDestroyIndirectCommandsLayoutNV( device, indirectCommandsLayout, pAllocator );
-    }
-
-    //=== VK_EXT_depth_bias_control ===
-
-    void vkCmdSetDepthBias2EXT( VkCommandBuffer commandBuffer, const VkDepthBiasInfoEXT * pDepthBiasInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetDepthBias2EXT( commandBuffer, pDepthBiasInfo );
-    }
-
-    //=== VK_EXT_acquire_drm_display ===
-
-    VkResult vkAcquireDrmDisplayEXT( VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkAcquireDrmDisplayEXT( physicalDevice, drmFd, display );
-    }
-
-    VkResult vkGetDrmDisplayEXT( VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId, VkDisplayKHR * display ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetDrmDisplayEXT( physicalDevice, drmFd, connectorId, display );
-    }
-
-    //=== VK_EXT_private_data ===
-
-    VkResult vkCreatePrivateDataSlotEXT( VkDevice                            device,
-                                         const VkPrivateDataSlotCreateInfo * pCreateInfo,
-                                         const VkAllocationCallbacks *       pAllocator,
-                                         VkPrivateDataSlot *                 pPrivateDataSlot ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreatePrivateDataSlotEXT( device, pCreateInfo, pAllocator, pPrivateDataSlot );
-    }
-
-    void vkDestroyPrivateDataSlotEXT( VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkDestroyPrivateDataSlotEXT( device, privateDataSlot, pAllocator );
-    }
-
-    VkResult vkSetPrivateDataEXT( VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data ) const
-      VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkSetPrivateDataEXT( device, objectType, objectHandle, privateDataSlot, data );
-    }
-
-    void vkGetPrivateDataEXT( VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t * pData ) const
-      VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPrivateDataEXT( device, objectType, objectHandle, privateDataSlot, pData );
-    }
-
-    //=== VK_KHR_video_encode_queue ===
-
-    VkResult
-      vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( VkPhysicalDevice                                       physicalDevice,
-                                                               const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR * pQualityLevelInfo,
-                                                               VkVideoEncodeQualityLevelPropertiesKHR * pQualityLevelProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( physicalDevice, pQualityLevelInfo, pQualityLevelProperties );
-    }
-
-    VkResult vkGetEncodedVideoSessionParametersKHR( VkDevice                                         device,
-                                                    const VkVideoEncodeSessionParametersGetInfoKHR * pVideoSessionParametersInfo,
-                                                    VkVideoEncodeSessionParametersFeedbackInfoKHR *  pFeedbackInfo,
-                                                    size_t *                                         pDataSize,
-                                                    void *                                           pData ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetEncodedVideoSessionParametersKHR( device, pVideoSessionParametersInfo, pFeedbackInfo, pDataSize, pData );
-    }
-
-    void vkCmdEncodeVideoKHR( VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR * pEncodeInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdEncodeVideoKHR( commandBuffer, pEncodeInfo );
-    }
-
-#  if defined( VK_ENABLE_BETA_EXTENSIONS )
-    //=== VK_NV_cuda_kernel_launch ===
-
-    VkResult vkCreateCudaModuleNV( VkDevice                         device,
-                                   const VkCudaModuleCreateInfoNV * pCreateInfo,
-                                   const VkAllocationCallbacks *    pAllocator,
-                                   VkCudaModuleNV *                 pModule ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateCudaModuleNV( device, pCreateInfo, pAllocator, pModule );
-    }
-
-    VkResult vkGetCudaModuleCacheNV( VkDevice device, VkCudaModuleNV module, size_t * pCacheSize, void * pCacheData ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetCudaModuleCacheNV( device, module, pCacheSize, pCacheData );
-    }
-
-    VkResult vkCreateCudaFunctionNV( VkDevice                           device,
-                                     const VkCudaFunctionCreateInfoNV * pCreateInfo,
-                                     const VkAllocationCallbacks *      pAllocator,
-                                     VkCudaFunctionNV *                 pFunction ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateCudaFunctionNV( device, pCreateInfo, pAllocator, pFunction );
-    }
-
-    void vkDestroyCudaModuleNV( VkDevice device, VkCudaModuleNV module, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkDestroyCudaModuleNV( device, module, pAllocator );
-    }
-
-    void vkDestroyCudaFunctionNV( VkDevice device, VkCudaFunctionNV function, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkDestroyCudaFunctionNV( device, function, pAllocator );
-    }
-
-    void vkCmdCudaLaunchKernelNV( VkCommandBuffer commandBuffer, const VkCudaLaunchInfoNV * pLaunchInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdCudaLaunchKernelNV( commandBuffer, pLaunchInfo );
-    }
-#  endif /*VK_ENABLE_BETA_EXTENSIONS*/
-
-#  if defined( VK_USE_PLATFORM_METAL_EXT )
-    //=== VK_EXT_metal_objects ===
-
-    void vkExportMetalObjectsEXT( VkDevice device, VkExportMetalObjectsInfoEXT * pMetalObjectsInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkExportMetalObjectsEXT( device, pMetalObjectsInfo );
-    }
-#  endif /*VK_USE_PLATFORM_METAL_EXT*/
-
-    //=== VK_KHR_synchronization2 ===
-
-    void vkCmdSetEvent2KHR( VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo * pDependencyInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetEvent2KHR( commandBuffer, event, pDependencyInfo );
-    }
-
-    void vkCmdResetEvent2KHR( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdResetEvent2KHR( commandBuffer, event, stageMask );
-    }
-
-    void vkCmdWaitEvents2KHR( VkCommandBuffer          commandBuffer,
-                              uint32_t                 eventCount,
-                              const VkEvent *          pEvents,
-                              const VkDependencyInfo * pDependencyInfos ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdWaitEvents2KHR( commandBuffer, eventCount, pEvents, pDependencyInfos );
-    }
-
-    void vkCmdPipelineBarrier2KHR( VkCommandBuffer commandBuffer, const VkDependencyInfo * pDependencyInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdPipelineBarrier2KHR( commandBuffer, pDependencyInfo );
-    }
-
-    void vkCmdWriteTimestamp2KHR( VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdWriteTimestamp2KHR( commandBuffer, stage, queryPool, query );
-    }
-
-    VkResult vkQueueSubmit2KHR( VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 * pSubmits, VkFence fence ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkQueueSubmit2KHR( queue, submitCount, pSubmits, fence );
-    }
-
-    //=== VK_EXT_descriptor_buffer ===
-
-    void vkGetDescriptorSetLayoutSizeEXT( VkDevice device, VkDescriptorSetLayout layout, VkDeviceSize * pLayoutSizeInBytes ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetDescriptorSetLayoutSizeEXT( device, layout, pLayoutSizeInBytes );
-    }
-
-    void vkGetDescriptorSetLayoutBindingOffsetEXT( VkDevice              device,
-                                                   VkDescriptorSetLayout layout,
-                                                   uint32_t              binding,
-                                                   VkDeviceSize *        pOffset ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetDescriptorSetLayoutBindingOffsetEXT( device, layout, binding, pOffset );
-    }
-
-    void vkGetDescriptorEXT( VkDevice device, const VkDescriptorGetInfoEXT * pDescriptorInfo, size_t dataSize, void * pDescriptor ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetDescriptorEXT( device, pDescriptorInfo, dataSize, pDescriptor );
-    }
-
-    void vkCmdBindDescriptorBuffersEXT( VkCommandBuffer                          commandBuffer,
-                                        uint32_t                                 bufferCount,
-                                        const VkDescriptorBufferBindingInfoEXT * pBindingInfos ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdBindDescriptorBuffersEXT( commandBuffer, bufferCount, pBindingInfos );
-    }
-
-    void vkCmdSetDescriptorBufferOffsetsEXT( VkCommandBuffer      commandBuffer,
-                                             VkPipelineBindPoint  pipelineBindPoint,
-                                             VkPipelineLayout     layout,
-                                             uint32_t             firstSet,
-                                             uint32_t             setCount,
-                                             const uint32_t *     pBufferIndices,
-                                             const VkDeviceSize * pOffsets ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetDescriptorBufferOffsetsEXT( commandBuffer, pipelineBindPoint, layout, firstSet, setCount, pBufferIndices, pOffsets );
-    }
-
-    void vkCmdBindDescriptorBufferEmbeddedSamplersEXT( VkCommandBuffer     commandBuffer,
-                                                       VkPipelineBindPoint pipelineBindPoint,
-                                                       VkPipelineLayout    layout,
-                                                       uint32_t            set ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdBindDescriptorBufferEmbeddedSamplersEXT( commandBuffer, pipelineBindPoint, layout, set );
-    }
-
-    VkResult
-      vkGetBufferOpaqueCaptureDescriptorDataEXT( VkDevice device, const VkBufferCaptureDescriptorDataInfoEXT * pInfo, void * pData ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetBufferOpaqueCaptureDescriptorDataEXT( device, pInfo, pData );
-    }
-
-    VkResult
-      vkGetImageOpaqueCaptureDescriptorDataEXT( VkDevice device, const VkImageCaptureDescriptorDataInfoEXT * pInfo, void * pData ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetImageOpaqueCaptureDescriptorDataEXT( device, pInfo, pData );
-    }
-
-    VkResult vkGetImageViewOpaqueCaptureDescriptorDataEXT( VkDevice                                        device,
-                                                           const VkImageViewCaptureDescriptorDataInfoEXT * pInfo,
-                                                           void *                                          pData ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetImageViewOpaqueCaptureDescriptorDataEXT( device, pInfo, pData );
-    }
-
-    VkResult
-      vkGetSamplerOpaqueCaptureDescriptorDataEXT( VkDevice device, const VkSamplerCaptureDescriptorDataInfoEXT * pInfo, void * pData ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetSamplerOpaqueCaptureDescriptorDataEXT( device, pInfo, pData );
-    }
-
-    VkResult vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT( VkDevice                                                    device,
-                                                                       const VkAccelerationStructureCaptureDescriptorDataInfoEXT * pInfo,
-                                                                       void * pData ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT( device, pInfo, pData );
-    }
-
-    //=== VK_NV_fragment_shading_rate_enums ===
-
-    void vkCmdSetFragmentShadingRateEnumNV( VkCommandBuffer                          commandBuffer,
-                                            VkFragmentShadingRateNV                  shadingRate,
-                                            const VkFragmentShadingRateCombinerOpKHR combinerOps[2] ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetFragmentShadingRateEnumNV( commandBuffer, shadingRate, combinerOps );
-    }
-
-    //=== VK_EXT_mesh_shader ===
-
-    void vkCmdDrawMeshTasksEXT( VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdDrawMeshTasksEXT( commandBuffer, groupCountX, groupCountY, groupCountZ );
-    }
-
-    void vkCmdDrawMeshTasksIndirectEXT( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride ) const
-      VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdDrawMeshTasksIndirectEXT( commandBuffer, buffer, offset, drawCount, stride );
-    }
-
-    void vkCmdDrawMeshTasksIndirectCountEXT( VkCommandBuffer commandBuffer,
+      void vkCmdDrawIndexedIndirectCountAMD( VkCommandBuffer commandBuffer,
                                              VkBuffer        buffer,
                                              VkDeviceSize    offset,
                                              VkBuffer        countBuffer,
                                              VkDeviceSize    countBufferOffset,
                                              uint32_t        maxDrawCount,
                                              uint32_t        stride ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdDrawMeshTasksIndirectCountEXT( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
-    }
+      {
+        return ::vkCmdDrawIndexedIndirectCountAMD( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
+      }
 
-    //=== VK_KHR_copy_commands2 ===
+      //=== VK_AMD_shader_info ===
 
-    void vkCmdCopyBuffer2KHR( VkCommandBuffer commandBuffer, const VkCopyBufferInfo2 * pCopyBufferInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdCopyBuffer2KHR( commandBuffer, pCopyBufferInfo );
-    }
+      VkResult vkGetShaderInfoAMD( VkDevice              device,
+                                   VkPipeline            pipeline,
+                                   VkShaderStageFlagBits shaderStage,
+                                   VkShaderInfoTypeAMD   infoType,
+                                   size_t *              pInfoSize,
+                                   void *                pInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetShaderInfoAMD( device, pipeline, shaderStage, infoType, pInfoSize, pInfo );
+      }
 
-    void vkCmdCopyImage2KHR( VkCommandBuffer commandBuffer, const VkCopyImageInfo2 * pCopyImageInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdCopyImage2KHR( commandBuffer, pCopyImageInfo );
-    }
+      //=== VK_KHR_dynamic_rendering ===
 
-    void vkCmdCopyBufferToImage2KHR( VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2 * pCopyBufferToImageInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdCopyBufferToImage2KHR( commandBuffer, pCopyBufferToImageInfo );
-    }
+      void vkCmdBeginRenderingKHR( VkCommandBuffer commandBuffer, const VkRenderingInfo * pRenderingInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdBeginRenderingKHR( commandBuffer, pRenderingInfo );
+      }
 
-    void vkCmdCopyImageToBuffer2KHR( VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2 * pCopyImageToBufferInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdCopyImageToBuffer2KHR( commandBuffer, pCopyImageToBufferInfo );
-    }
+      void vkCmdEndRenderingKHR( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdEndRenderingKHR( commandBuffer );
+      }
 
-    void vkCmdBlitImage2KHR( VkCommandBuffer commandBuffer, const VkBlitImageInfo2 * pBlitImageInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdBlitImage2KHR( commandBuffer, pBlitImageInfo );
-    }
+#  if defined( VK_USE_PLATFORM_GGP )
+      //=== VK_GGP_stream_descriptor_surface ===
 
-    void vkCmdResolveImage2KHR( VkCommandBuffer commandBuffer, const VkResolveImageInfo2 * pResolveImageInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdResolveImage2KHR( commandBuffer, pResolveImageInfo );
-    }
+      VkResult vkCreateStreamDescriptorSurfaceGGP( VkInstance                                     instance,
+                                                   const VkStreamDescriptorSurfaceCreateInfoGGP * pCreateInfo,
+                                                   const VkAllocationCallbacks *                  pAllocator,
+                                                   VkSurfaceKHR *                                 pSurface ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateStreamDescriptorSurfaceGGP( instance, pCreateInfo, pAllocator, pSurface );
+      }
+#  endif /*VK_USE_PLATFORM_GGP*/
 
-    //=== VK_EXT_device_fault ===
+      //=== VK_NV_external_memory_capabilities ===
 
-    VkResult vkGetDeviceFaultInfoEXT( VkDevice device, VkDeviceFaultCountsEXT * pFaultCounts, VkDeviceFaultInfoEXT * pFaultInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetDeviceFaultInfoEXT( device, pFaultCounts, pFaultInfo );
-    }
+      VkResult
+        vkGetPhysicalDeviceExternalImageFormatPropertiesNV( VkPhysicalDevice                    physicalDevice,
+                                                            VkFormat                            format,
+                                                            VkImageType                         type,
+                                                            VkImageTiling                       tiling,
+                                                            VkImageUsageFlags                   usage,
+                                                            VkImageCreateFlags                  flags,
+                                                            VkExternalMemoryHandleTypeFlagsNV   externalHandleType,
+                                                            VkExternalImageFormatPropertiesNV * pExternalImageFormatProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
+          physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties );
+      }
 
 #  if defined( VK_USE_PLATFORM_WIN32_KHR )
-    //=== VK_NV_acquire_winrt_display ===
+      //=== VK_NV_external_memory_win32 ===
 
-    VkResult vkAcquireWinrtDisplayNV( VkPhysicalDevice physicalDevice, VkDisplayKHR display ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkAcquireWinrtDisplayNV( physicalDevice, display );
-    }
+      VkResult vkGetMemoryWin32HandleNV( VkDevice                          device,
+                                         VkDeviceMemory                    memory,
+                                         VkExternalMemoryHandleTypeFlagsNV handleType,
+                                         HANDLE *                          pHandle ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetMemoryWin32HandleNV( device, memory, handleType, pHandle );
+      }
+#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
-    VkResult vkGetWinrtDisplayNV( VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, VkDisplayKHR * pDisplay ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetWinrtDisplayNV( physicalDevice, deviceRelativeId, pDisplay );
-    }
+      //=== VK_KHR_get_physical_device_properties2 ===
+
+      void vkGetPhysicalDeviceFeatures2KHR( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 * pFeatures ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceFeatures2KHR( physicalDevice, pFeatures );
+      }
+
+      void vkGetPhysicalDeviceProperties2KHR( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 * pProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceProperties2KHR( physicalDevice, pProperties );
+      }
+
+      void vkGetPhysicalDeviceFormatProperties2KHR( VkPhysicalDevice      physicalDevice,
+                                                    VkFormat              format,
+                                                    VkFormatProperties2 * pFormatProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceFormatProperties2KHR( physicalDevice, format, pFormatProperties );
+      }
+
+      VkResult vkGetPhysicalDeviceImageFormatProperties2KHR( VkPhysicalDevice                         physicalDevice,
+                                                             const VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo,
+                                                             VkImageFormatProperties2 *               pImageFormatProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceImageFormatProperties2KHR( physicalDevice, pImageFormatInfo, pImageFormatProperties );
+      }
+
+      void vkGetPhysicalDeviceQueueFamilyProperties2KHR( VkPhysicalDevice           physicalDevice,
+                                                         uint32_t *                 pQueueFamilyPropertyCount,
+                                                         VkQueueFamilyProperties2 * pQueueFamilyProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceQueueFamilyProperties2KHR( physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties );
+      }
+
+      void vkGetPhysicalDeviceMemoryProperties2KHR( VkPhysicalDevice                    physicalDevice,
+                                                    VkPhysicalDeviceMemoryProperties2 * pMemoryProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceMemoryProperties2KHR( physicalDevice, pMemoryProperties );
+      }
+
+      void vkGetPhysicalDeviceSparseImageFormatProperties2KHR( VkPhysicalDevice                               physicalDevice,
+                                                               const VkPhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,
+                                                               uint32_t *                                     pPropertyCount,
+                                                               VkSparseImageFormatProperties2 *               pProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceSparseImageFormatProperties2KHR( physicalDevice, pFormatInfo, pPropertyCount, pProperties );
+      }
+
+      //=== VK_KHR_device_group ===
+
+      void vkGetDeviceGroupPeerMemoryFeaturesKHR( VkDevice                   device,
+                                                  uint32_t                   heapIndex,
+                                                  uint32_t                   localDeviceIndex,
+                                                  uint32_t                   remoteDeviceIndex,
+                                                  VkPeerMemoryFeatureFlags * pPeerMemoryFeatures ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetDeviceGroupPeerMemoryFeaturesKHR( device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures );
+      }
+
+      void vkCmdSetDeviceMaskKHR( VkCommandBuffer commandBuffer, uint32_t deviceMask ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetDeviceMaskKHR( commandBuffer, deviceMask );
+      }
+
+      void vkCmdDispatchBaseKHR( VkCommandBuffer commandBuffer,
+                                 uint32_t        baseGroupX,
+                                 uint32_t        baseGroupY,
+                                 uint32_t        baseGroupZ,
+                                 uint32_t        groupCountX,
+                                 uint32_t        groupCountY,
+                                 uint32_t        groupCountZ ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdDispatchBaseKHR( commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ );
+      }
+
+#  if defined( VK_USE_PLATFORM_VI_NN )
+      //=== VK_NN_vi_surface ===
+
+      VkResult vkCreateViSurfaceNN( VkInstance                      instance,
+                                    const VkViSurfaceCreateInfoNN * pCreateInfo,
+                                    const VkAllocationCallbacks *   pAllocator,
+                                    VkSurfaceKHR *                  pSurface ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateViSurfaceNN( instance, pCreateInfo, pAllocator, pSurface );
+      }
+#  endif /*VK_USE_PLATFORM_VI_NN*/
+
+      //=== VK_KHR_maintenance1 ===
+
+      void vkTrimCommandPoolKHR( VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkTrimCommandPoolKHR( device, commandPool, flags );
+      }
+
+      //=== VK_KHR_device_group_creation ===
+
+      VkResult vkEnumeratePhysicalDeviceGroupsKHR( VkInstance                        instance,
+                                                   uint32_t *                        pPhysicalDeviceGroupCount,
+                                                   VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkEnumeratePhysicalDeviceGroupsKHR( instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties );
+      }
+
+      //=== VK_KHR_external_memory_capabilities ===
+
+      void vkGetPhysicalDeviceExternalBufferPropertiesKHR( VkPhysicalDevice                           physicalDevice,
+                                                           const VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo,
+                                                           VkExternalBufferProperties *               pExternalBufferProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceExternalBufferPropertiesKHR( physicalDevice, pExternalBufferInfo, pExternalBufferProperties );
+      }
+
+#  if defined( VK_USE_PLATFORM_WIN32_KHR )
+      //=== VK_KHR_external_memory_win32 ===
+
+      VkResult
+        vkGetMemoryWin32HandleKHR( VkDevice device, const VkMemoryGetWin32HandleInfoKHR * pGetWin32HandleInfo, HANDLE * pHandle ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetMemoryWin32HandleKHR( device, pGetWin32HandleInfo, pHandle );
+      }
+
+      VkResult vkGetMemoryWin32HandlePropertiesKHR( VkDevice                           device,
+                                                    VkExternalMemoryHandleTypeFlagBits handleType,
+                                                    HANDLE                             handle,
+                                                    VkMemoryWin32HandlePropertiesKHR * pMemoryWin32HandleProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetMemoryWin32HandlePropertiesKHR( device, handleType, handle, pMemoryWin32HandleProperties );
+      }
+#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+      //=== VK_KHR_external_memory_fd ===
+
+      VkResult vkGetMemoryFdKHR( VkDevice device, const VkMemoryGetFdInfoKHR * pGetFdInfo, int * pFd ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetMemoryFdKHR( device, pGetFdInfo, pFd );
+      }
+
+      VkResult vkGetMemoryFdPropertiesKHR( VkDevice                           device,
+                                           VkExternalMemoryHandleTypeFlagBits handleType,
+                                           int                                fd,
+                                           VkMemoryFdPropertiesKHR *          pMemoryFdProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetMemoryFdPropertiesKHR( device, handleType, fd, pMemoryFdProperties );
+      }
+
+      //=== VK_KHR_external_semaphore_capabilities ===
+
+      void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( VkPhysicalDevice                              physicalDevice,
+                                                              const VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,
+                                                              VkExternalSemaphoreProperties * pExternalSemaphoreProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties );
+      }
+
+#  if defined( VK_USE_PLATFORM_WIN32_KHR )
+      //=== VK_KHR_external_semaphore_win32 ===
+
+      VkResult vkImportSemaphoreWin32HandleKHR( VkDevice                                    device,
+                                                const VkImportSemaphoreWin32HandleInfoKHR * pImportSemaphoreWin32HandleInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkImportSemaphoreWin32HandleKHR( device, pImportSemaphoreWin32HandleInfo );
+      }
+
+      VkResult vkGetSemaphoreWin32HandleKHR( VkDevice                                 device,
+                                             const VkSemaphoreGetWin32HandleInfoKHR * pGetWin32HandleInfo,
+                                             HANDLE *                                 pHandle ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetSemaphoreWin32HandleKHR( device, pGetWin32HandleInfo, pHandle );
+      }
+#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+      //=== VK_KHR_external_semaphore_fd ===
+
+      VkResult vkImportSemaphoreFdKHR( VkDevice device, const VkImportSemaphoreFdInfoKHR * pImportSemaphoreFdInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkImportSemaphoreFdKHR( device, pImportSemaphoreFdInfo );
+      }
+
+      VkResult vkGetSemaphoreFdKHR( VkDevice device, const VkSemaphoreGetFdInfoKHR * pGetFdInfo, int * pFd ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetSemaphoreFdKHR( device, pGetFdInfo, pFd );
+      }
+
+      //=== VK_KHR_push_descriptor ===
+
+      void vkCmdPushDescriptorSetKHR( VkCommandBuffer              commandBuffer,
+                                      VkPipelineBindPoint          pipelineBindPoint,
+                                      VkPipelineLayout             layout,
+                                      uint32_t                     set,
+                                      uint32_t                     descriptorWriteCount,
+                                      const VkWriteDescriptorSet * pDescriptorWrites ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdPushDescriptorSetKHR( commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites );
+      }
+
+      void vkCmdPushDescriptorSetWithTemplateKHR( VkCommandBuffer            commandBuffer,
+                                                  VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+                                                  VkPipelineLayout           layout,
+                                                  uint32_t                   set,
+                                                  const void *               pData ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdPushDescriptorSetWithTemplateKHR( commandBuffer, descriptorUpdateTemplate, layout, set, pData );
+      }
+
+      //=== VK_EXT_conditional_rendering ===
+
+      void vkCmdBeginConditionalRenderingEXT( VkCommandBuffer                            commandBuffer,
+                                              const VkConditionalRenderingBeginInfoEXT * pConditionalRenderingBegin ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdBeginConditionalRenderingEXT( commandBuffer, pConditionalRenderingBegin );
+      }
+
+      void vkCmdEndConditionalRenderingEXT( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdEndConditionalRenderingEXT( commandBuffer );
+      }
+
+      //=== VK_KHR_descriptor_update_template ===
+
+      VkResult vkCreateDescriptorUpdateTemplateKHR( VkDevice                                     device,
+                                                    const VkDescriptorUpdateTemplateCreateInfo * pCreateInfo,
+                                                    const VkAllocationCallbacks *                pAllocator,
+                                                    VkDescriptorUpdateTemplate *                 pDescriptorUpdateTemplate ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateDescriptorUpdateTemplateKHR( device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate );
+      }
+
+      void vkDestroyDescriptorUpdateTemplateKHR( VkDevice                      device,
+                                                 VkDescriptorUpdateTemplate    descriptorUpdateTemplate,
+                                                 const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkDestroyDescriptorUpdateTemplateKHR( device, descriptorUpdateTemplate, pAllocator );
+      }
+
+      void vkUpdateDescriptorSetWithTemplateKHR( VkDevice                   device,
+                                                 VkDescriptorSet            descriptorSet,
+                                                 VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+                                                 const void *               pData ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkUpdateDescriptorSetWithTemplateKHR( device, descriptorSet, descriptorUpdateTemplate, pData );
+      }
+
+      //=== VK_NV_clip_space_w_scaling ===
+
+      void vkCmdSetViewportWScalingNV( VkCommandBuffer              commandBuffer,
+                                       uint32_t                     firstViewport,
+                                       uint32_t                     viewportCount,
+                                       const VkViewportWScalingNV * pViewportWScalings ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetViewportWScalingNV( commandBuffer, firstViewport, viewportCount, pViewportWScalings );
+      }
+
+      //=== VK_EXT_direct_mode_display ===
+
+      VkResult vkReleaseDisplayEXT( VkPhysicalDevice physicalDevice, VkDisplayKHR display ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkReleaseDisplayEXT( physicalDevice, display );
+      }
+
+#  if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
+      //=== VK_EXT_acquire_xlib_display ===
+
+      VkResult vkAcquireXlibDisplayEXT( VkPhysicalDevice physicalDevice, Display * dpy, VkDisplayKHR display ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkAcquireXlibDisplayEXT( physicalDevice, dpy, display );
+      }
+
+      VkResult
+        vkGetRandROutputDisplayEXT( VkPhysicalDevice physicalDevice, Display * dpy, RROutput rrOutput, VkDisplayKHR * pDisplay ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetRandROutputDisplayEXT( physicalDevice, dpy, rrOutput, pDisplay );
+      }
+#  endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
+
+      //=== VK_EXT_display_surface_counter ===
+
+      VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT( VkPhysicalDevice            physicalDevice,
+                                                           VkSurfaceKHR                surface,
+                                                           VkSurfaceCapabilities2EXT * pSurfaceCapabilities ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceSurfaceCapabilities2EXT( physicalDevice, surface, pSurfaceCapabilities );
+      }
+
+      //=== VK_EXT_display_control ===
+
+      VkResult vkDisplayPowerControlEXT( VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT * pDisplayPowerInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkDisplayPowerControlEXT( device, display, pDisplayPowerInfo );
+      }
+
+      VkResult vkRegisterDeviceEventEXT( VkDevice                      device,
+                                         const VkDeviceEventInfoEXT *  pDeviceEventInfo,
+                                         const VkAllocationCallbacks * pAllocator,
+                                         VkFence *                     pFence ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkRegisterDeviceEventEXT( device, pDeviceEventInfo, pAllocator, pFence );
+      }
+
+      VkResult vkRegisterDisplayEventEXT( VkDevice                      device,
+                                          VkDisplayKHR                  display,
+                                          const VkDisplayEventInfoEXT * pDisplayEventInfo,
+                                          const VkAllocationCallbacks * pAllocator,
+                                          VkFence *                     pFence ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkRegisterDisplayEventEXT( device, display, pDisplayEventInfo, pAllocator, pFence );
+      }
+
+      VkResult vkGetSwapchainCounterEXT( VkDevice                    device,
+                                         VkSwapchainKHR              swapchain,
+                                         VkSurfaceCounterFlagBitsEXT counter,
+                                         uint64_t *                  pCounterValue ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetSwapchainCounterEXT( device, swapchain, counter, pCounterValue );
+      }
+
+      //=== VK_GOOGLE_display_timing ===
+
+      VkResult vkGetRefreshCycleDurationGOOGLE( VkDevice                       device,
+                                                VkSwapchainKHR                 swapchain,
+                                                VkRefreshCycleDurationGOOGLE * pDisplayTimingProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetRefreshCycleDurationGOOGLE( device, swapchain, pDisplayTimingProperties );
+      }
+
+      VkResult vkGetPastPresentationTimingGOOGLE( VkDevice                         device,
+                                                  VkSwapchainKHR                   swapchain,
+                                                  uint32_t *                       pPresentationTimingCount,
+                                                  VkPastPresentationTimingGOOGLE * pPresentationTimings ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPastPresentationTimingGOOGLE( device, swapchain, pPresentationTimingCount, pPresentationTimings );
+      }
+
+      //=== VK_EXT_discard_rectangles ===
+
+      void vkCmdSetDiscardRectangleEXT( VkCommandBuffer  commandBuffer,
+                                        uint32_t         firstDiscardRectangle,
+                                        uint32_t         discardRectangleCount,
+                                        const VkRect2D * pDiscardRectangles ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetDiscardRectangleEXT( commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles );
+      }
+
+      void vkCmdSetDiscardRectangleEnableEXT( VkCommandBuffer commandBuffer, VkBool32 discardRectangleEnable ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetDiscardRectangleEnableEXT( commandBuffer, discardRectangleEnable );
+      }
+
+      void vkCmdSetDiscardRectangleModeEXT( VkCommandBuffer commandBuffer, VkDiscardRectangleModeEXT discardRectangleMode ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetDiscardRectangleModeEXT( commandBuffer, discardRectangleMode );
+      }
+
+      //=== VK_EXT_hdr_metadata ===
+
+      void vkSetHdrMetadataEXT( VkDevice                 device,
+                                uint32_t                 swapchainCount,
+                                const VkSwapchainKHR *   pSwapchains,
+                                const VkHdrMetadataEXT * pMetadata ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkSetHdrMetadataEXT( device, swapchainCount, pSwapchains, pMetadata );
+      }
+
+      //=== VK_KHR_create_renderpass2 ===
+
+      VkResult vkCreateRenderPass2KHR( VkDevice                        device,
+                                       const VkRenderPassCreateInfo2 * pCreateInfo,
+                                       const VkAllocationCallbacks *   pAllocator,
+                                       VkRenderPass *                  pRenderPass ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateRenderPass2KHR( device, pCreateInfo, pAllocator, pRenderPass );
+      }
+
+      void vkCmdBeginRenderPass2KHR( VkCommandBuffer               commandBuffer,
+                                     const VkRenderPassBeginInfo * pRenderPassBegin,
+                                     const VkSubpassBeginInfo *    pSubpassBeginInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdBeginRenderPass2KHR( commandBuffer, pRenderPassBegin, pSubpassBeginInfo );
+      }
+
+      void vkCmdNextSubpass2KHR( VkCommandBuffer            commandBuffer,
+                                 const VkSubpassBeginInfo * pSubpassBeginInfo,
+                                 const VkSubpassEndInfo *   pSubpassEndInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdNextSubpass2KHR( commandBuffer, pSubpassBeginInfo, pSubpassEndInfo );
+      }
+
+      void vkCmdEndRenderPass2KHR( VkCommandBuffer commandBuffer, const VkSubpassEndInfo * pSubpassEndInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdEndRenderPass2KHR( commandBuffer, pSubpassEndInfo );
+      }
+
+      //=== VK_KHR_shared_presentable_image ===
+
+      VkResult vkGetSwapchainStatusKHR( VkDevice device, VkSwapchainKHR swapchain ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetSwapchainStatusKHR( device, swapchain );
+      }
+
+      //=== VK_KHR_external_fence_capabilities ===
+
+      void vkGetPhysicalDeviceExternalFencePropertiesKHR( VkPhysicalDevice                          physicalDevice,
+                                                          const VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo,
+                                                          VkExternalFenceProperties *               pExternalFenceProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceExternalFencePropertiesKHR( physicalDevice, pExternalFenceInfo, pExternalFenceProperties );
+      }
+
+#  if defined( VK_USE_PLATFORM_WIN32_KHR )
+      //=== VK_KHR_external_fence_win32 ===
+
+      VkResult vkImportFenceWin32HandleKHR( VkDevice device, const VkImportFenceWin32HandleInfoKHR * pImportFenceWin32HandleInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkImportFenceWin32HandleKHR( device, pImportFenceWin32HandleInfo );
+      }
+
+      VkResult vkGetFenceWin32HandleKHR( VkDevice device, const VkFenceGetWin32HandleInfoKHR * pGetWin32HandleInfo, HANDLE * pHandle ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetFenceWin32HandleKHR( device, pGetWin32HandleInfo, pHandle );
+      }
+#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+      //=== VK_KHR_external_fence_fd ===
+
+      VkResult vkImportFenceFdKHR( VkDevice device, const VkImportFenceFdInfoKHR * pImportFenceFdInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkImportFenceFdKHR( device, pImportFenceFdInfo );
+      }
+
+      VkResult vkGetFenceFdKHR( VkDevice device, const VkFenceGetFdInfoKHR * pGetFdInfo, int * pFd ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetFenceFdKHR( device, pGetFdInfo, pFd );
+      }
+
+      //=== VK_KHR_performance_query ===
+
+      VkResult
+        vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( VkPhysicalDevice                     physicalDevice,
+                                                                         uint32_t                             queueFamilyIndex,
+                                                                         uint32_t *                           pCounterCount,
+                                                                         VkPerformanceCounterKHR *            pCounters,
+                                                                         VkPerformanceCounterDescriptionKHR * pCounterDescriptions ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
+          physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions );
+      }
+
+      void vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( VkPhysicalDevice                            physicalDevice,
+                                                                    const VkQueryPoolPerformanceCreateInfoKHR * pPerformanceQueryCreateInfo,
+                                                                    uint32_t *                                  pNumPasses ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( physicalDevice, pPerformanceQueryCreateInfo, pNumPasses );
+      }
+
+      VkResult vkAcquireProfilingLockKHR( VkDevice device, const VkAcquireProfilingLockInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkAcquireProfilingLockKHR( device, pInfo );
+      }
+
+      void vkReleaseProfilingLockKHR( VkDevice device ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkReleaseProfilingLockKHR( device );
+      }
+
+      //=== VK_KHR_get_surface_capabilities2 ===
+
+      VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR( VkPhysicalDevice                        physicalDevice,
+                                                           const VkPhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
+                                                           VkSurfaceCapabilities2KHR *             pSurfaceCapabilities ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceSurfaceCapabilities2KHR( physicalDevice, pSurfaceInfo, pSurfaceCapabilities );
+      }
+
+      VkResult vkGetPhysicalDeviceSurfaceFormats2KHR( VkPhysicalDevice                        physicalDevice,
+                                                      const VkPhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
+                                                      uint32_t *                              pSurfaceFormatCount,
+                                                      VkSurfaceFormat2KHR *                   pSurfaceFormats ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceSurfaceFormats2KHR( physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats );
+      }
+
+      //=== VK_KHR_get_display_properties2 ===
+
+      VkResult vkGetPhysicalDeviceDisplayProperties2KHR( VkPhysicalDevice          physicalDevice,
+                                                         uint32_t *                pPropertyCount,
+                                                         VkDisplayProperties2KHR * pProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceDisplayProperties2KHR( physicalDevice, pPropertyCount, pProperties );
+      }
+
+      VkResult vkGetPhysicalDeviceDisplayPlaneProperties2KHR( VkPhysicalDevice               physicalDevice,
+                                                              uint32_t *                     pPropertyCount,
+                                                              VkDisplayPlaneProperties2KHR * pProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceDisplayPlaneProperties2KHR( physicalDevice, pPropertyCount, pProperties );
+      }
+
+      VkResult vkGetDisplayModeProperties2KHR( VkPhysicalDevice              physicalDevice,
+                                               VkDisplayKHR                  display,
+                                               uint32_t *                    pPropertyCount,
+                                               VkDisplayModeProperties2KHR * pProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetDisplayModeProperties2KHR( physicalDevice, display, pPropertyCount, pProperties );
+      }
+
+      VkResult vkGetDisplayPlaneCapabilities2KHR( VkPhysicalDevice                 physicalDevice,
+                                                  const VkDisplayPlaneInfo2KHR *   pDisplayPlaneInfo,
+                                                  VkDisplayPlaneCapabilities2KHR * pCapabilities ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetDisplayPlaneCapabilities2KHR( physicalDevice, pDisplayPlaneInfo, pCapabilities );
+      }
+
+#  if defined( VK_USE_PLATFORM_IOS_MVK )
+      //=== VK_MVK_ios_surface ===
+
+      VkResult vkCreateIOSSurfaceMVK( VkInstance                        instance,
+                                      const VkIOSSurfaceCreateInfoMVK * pCreateInfo,
+                                      const VkAllocationCallbacks *     pAllocator,
+                                      VkSurfaceKHR *                    pSurface ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateIOSSurfaceMVK( instance, pCreateInfo, pAllocator, pSurface );
+      }
+#  endif /*VK_USE_PLATFORM_IOS_MVK*/
+
+#  if defined( VK_USE_PLATFORM_MACOS_MVK )
+      //=== VK_MVK_macos_surface ===
+
+      VkResult vkCreateMacOSSurfaceMVK( VkInstance                          instance,
+                                        const VkMacOSSurfaceCreateInfoMVK * pCreateInfo,
+                                        const VkAllocationCallbacks *       pAllocator,
+                                        VkSurfaceKHR *                      pSurface ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateMacOSSurfaceMVK( instance, pCreateInfo, pAllocator, pSurface );
+      }
+#  endif /*VK_USE_PLATFORM_MACOS_MVK*/
+
+      //=== VK_EXT_debug_utils ===
+
+      VkResult vkSetDebugUtilsObjectNameEXT( VkDevice device, const VkDebugUtilsObjectNameInfoEXT * pNameInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkSetDebugUtilsObjectNameEXT( device, pNameInfo );
+      }
+
+      VkResult vkSetDebugUtilsObjectTagEXT( VkDevice device, const VkDebugUtilsObjectTagInfoEXT * pTagInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkSetDebugUtilsObjectTagEXT( device, pTagInfo );
+      }
+
+      void vkQueueBeginDebugUtilsLabelEXT( VkQueue queue, const VkDebugUtilsLabelEXT * pLabelInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkQueueBeginDebugUtilsLabelEXT( queue, pLabelInfo );
+      }
+
+      void vkQueueEndDebugUtilsLabelEXT( VkQueue queue ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkQueueEndDebugUtilsLabelEXT( queue );
+      }
+
+      void vkQueueInsertDebugUtilsLabelEXT( VkQueue queue, const VkDebugUtilsLabelEXT * pLabelInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkQueueInsertDebugUtilsLabelEXT( queue, pLabelInfo );
+      }
+
+      void vkCmdBeginDebugUtilsLabelEXT( VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT * pLabelInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdBeginDebugUtilsLabelEXT( commandBuffer, pLabelInfo );
+      }
+
+      void vkCmdEndDebugUtilsLabelEXT( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdEndDebugUtilsLabelEXT( commandBuffer );
+      }
+
+      void vkCmdInsertDebugUtilsLabelEXT( VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT * pLabelInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdInsertDebugUtilsLabelEXT( commandBuffer, pLabelInfo );
+      }
+
+      VkResult vkCreateDebugUtilsMessengerEXT( VkInstance                                 instance,
+                                               const VkDebugUtilsMessengerCreateInfoEXT * pCreateInfo,
+                                               const VkAllocationCallbacks *              pAllocator,
+                                               VkDebugUtilsMessengerEXT *                 pMessenger ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateDebugUtilsMessengerEXT( instance, pCreateInfo, pAllocator, pMessenger );
+      }
+
+      void vkDestroyDebugUtilsMessengerEXT( VkInstance                    instance,
+                                            VkDebugUtilsMessengerEXT      messenger,
+                                            const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkDestroyDebugUtilsMessengerEXT( instance, messenger, pAllocator );
+      }
+
+      void vkSubmitDebugUtilsMessageEXT( VkInstance                                   instance,
+                                         VkDebugUtilsMessageSeverityFlagBitsEXT       messageSeverity,
+                                         VkDebugUtilsMessageTypeFlagsEXT              messageTypes,
+                                         const VkDebugUtilsMessengerCallbackDataEXT * pCallbackData ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkSubmitDebugUtilsMessageEXT( instance, messageSeverity, messageTypes, pCallbackData );
+      }
+
+#  if defined( VK_USE_PLATFORM_ANDROID_KHR )
+      //=== VK_ANDROID_external_memory_android_hardware_buffer ===
+
+      VkResult vkGetAndroidHardwareBufferPropertiesANDROID( VkDevice                                   device,
+                                                            const struct AHardwareBuffer *             buffer,
+                                                            VkAndroidHardwareBufferPropertiesANDROID * pProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetAndroidHardwareBufferPropertiesANDROID( device, buffer, pProperties );
+      }
+
+      VkResult vkGetMemoryAndroidHardwareBufferANDROID( VkDevice                                            device,
+                                                        const VkMemoryGetAndroidHardwareBufferInfoANDROID * pInfo,
+                                                        struct AHardwareBuffer **                           pBuffer ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetMemoryAndroidHardwareBufferANDROID( device, pInfo, pBuffer );
+      }
+#  endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+
+#  if defined( VK_ENABLE_BETA_EXTENSIONS )
+      //=== VK_AMDX_shader_enqueue ===
+
+      VkResult vkCreateExecutionGraphPipelinesAMDX( VkDevice                                       device,
+                                                    VkPipelineCache                                pipelineCache,
+                                                    uint32_t                                       createInfoCount,
+                                                    const VkExecutionGraphPipelineCreateInfoAMDX * pCreateInfos,
+                                                    const VkAllocationCallbacks *                  pAllocator,
+                                                    VkPipeline *                                   pPipelines ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateExecutionGraphPipelinesAMDX( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines );
+      }
+
+      VkResult vkGetExecutionGraphPipelineScratchSizeAMDX( VkDevice                                  device,
+                                                           VkPipeline                                executionGraph,
+                                                           VkExecutionGraphPipelineScratchSizeAMDX * pSizeInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetExecutionGraphPipelineScratchSizeAMDX( device, executionGraph, pSizeInfo );
+      }
+
+      VkResult vkGetExecutionGraphPipelineNodeIndexAMDX( VkDevice                                        device,
+                                                         VkPipeline                                      executionGraph,
+                                                         const VkPipelineShaderStageNodeCreateInfoAMDX * pNodeInfo,
+                                                         uint32_t *                                      pNodeIndex ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetExecutionGraphPipelineNodeIndexAMDX( device, executionGraph, pNodeInfo, pNodeIndex );
+      }
+
+      void vkCmdInitializeGraphScratchMemoryAMDX( VkCommandBuffer commandBuffer,
+                                                  VkPipeline      executionGraph,
+                                                  VkDeviceAddress scratch,
+                                                  VkDeviceSize    scratchSize ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdInitializeGraphScratchMemoryAMDX( commandBuffer, executionGraph, scratch, scratchSize );
+      }
+
+      void vkCmdDispatchGraphAMDX( VkCommandBuffer                      commandBuffer,
+                                   VkDeviceAddress                      scratch,
+                                   VkDeviceSize                         scratchSize,
+                                   const VkDispatchGraphCountInfoAMDX * pCountInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdDispatchGraphAMDX( commandBuffer, scratch, scratchSize, pCountInfo );
+      }
+
+      void vkCmdDispatchGraphIndirectAMDX( VkCommandBuffer                      commandBuffer,
+                                           VkDeviceAddress                      scratch,
+                                           VkDeviceSize                         scratchSize,
+                                           const VkDispatchGraphCountInfoAMDX * pCountInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdDispatchGraphIndirectAMDX( commandBuffer, scratch, scratchSize, pCountInfo );
+      }
+
+      void vkCmdDispatchGraphIndirectCountAMDX( VkCommandBuffer commandBuffer,
+                                                VkDeviceAddress scratch,
+                                                VkDeviceSize    scratchSize,
+                                                VkDeviceAddress countInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdDispatchGraphIndirectCountAMDX( commandBuffer, scratch, scratchSize, countInfo );
+      }
+#  endif /*VK_ENABLE_BETA_EXTENSIONS*/
+
+      //=== VK_EXT_sample_locations ===
+
+      void vkCmdSetSampleLocationsEXT( VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT * pSampleLocationsInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetSampleLocationsEXT( commandBuffer, pSampleLocationsInfo );
+      }
+
+      void vkGetPhysicalDeviceMultisamplePropertiesEXT( VkPhysicalDevice             physicalDevice,
+                                                        VkSampleCountFlagBits        samples,
+                                                        VkMultisamplePropertiesEXT * pMultisampleProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceMultisamplePropertiesEXT( physicalDevice, samples, pMultisampleProperties );
+      }
+
+      //=== VK_KHR_get_memory_requirements2 ===
+
+      void vkGetImageMemoryRequirements2KHR( VkDevice                               device,
+                                             const VkImageMemoryRequirementsInfo2 * pInfo,
+                                             VkMemoryRequirements2 *                pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetImageMemoryRequirements2KHR( device, pInfo, pMemoryRequirements );
+      }
+
+      void vkGetBufferMemoryRequirements2KHR( VkDevice                                device,
+                                              const VkBufferMemoryRequirementsInfo2 * pInfo,
+                                              VkMemoryRequirements2 *                 pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetBufferMemoryRequirements2KHR( device, pInfo, pMemoryRequirements );
+      }
+
+      void vkGetImageSparseMemoryRequirements2KHR( VkDevice                                     device,
+                                                   const VkImageSparseMemoryRequirementsInfo2 * pInfo,
+                                                   uint32_t *                                   pSparseMemoryRequirementCount,
+                                                   VkSparseImageMemoryRequirements2 *           pSparseMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetImageSparseMemoryRequirements2KHR( device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements );
+      }
+
+      //=== VK_KHR_acceleration_structure ===
+
+      VkResult vkCreateAccelerationStructureKHR( VkDevice                                     device,
+                                                 const VkAccelerationStructureCreateInfoKHR * pCreateInfo,
+                                                 const VkAllocationCallbacks *                pAllocator,
+                                                 VkAccelerationStructureKHR *                 pAccelerationStructure ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateAccelerationStructureKHR( device, pCreateInfo, pAllocator, pAccelerationStructure );
+      }
+
+      void vkDestroyAccelerationStructureKHR( VkDevice                      device,
+                                              VkAccelerationStructureKHR    accelerationStructure,
+                                              const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkDestroyAccelerationStructureKHR( device, accelerationStructure, pAllocator );
+      }
+
+      void vkCmdBuildAccelerationStructuresKHR( VkCommandBuffer                                          commandBuffer,
+                                                uint32_t                                                 infoCount,
+                                                const VkAccelerationStructureBuildGeometryInfoKHR *      pInfos,
+                                                const VkAccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdBuildAccelerationStructuresKHR( commandBuffer, infoCount, pInfos, ppBuildRangeInfos );
+      }
+
+      void vkCmdBuildAccelerationStructuresIndirectKHR( VkCommandBuffer                                     commandBuffer,
+                                                        uint32_t                                            infoCount,
+                                                        const VkAccelerationStructureBuildGeometryInfoKHR * pInfos,
+                                                        const VkDeviceAddress *                             pIndirectDeviceAddresses,
+                                                        const uint32_t *                                    pIndirectStrides,
+                                                        const uint32_t * const *                            ppMaxPrimitiveCounts ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdBuildAccelerationStructuresIndirectKHR(
+          commandBuffer, infoCount, pInfos, pIndirectDeviceAddresses, pIndirectStrides, ppMaxPrimitiveCounts );
+      }
+
+      VkResult vkBuildAccelerationStructuresKHR( VkDevice                                                 device,
+                                                 VkDeferredOperationKHR                                   deferredOperation,
+                                                 uint32_t                                                 infoCount,
+                                                 const VkAccelerationStructureBuildGeometryInfoKHR *      pInfos,
+                                                 const VkAccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkBuildAccelerationStructuresKHR( device, deferredOperation, infoCount, pInfos, ppBuildRangeInfos );
+      }
+
+      VkResult vkCopyAccelerationStructureKHR( VkDevice                                   device,
+                                               VkDeferredOperationKHR                     deferredOperation,
+                                               const VkCopyAccelerationStructureInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCopyAccelerationStructureKHR( device, deferredOperation, pInfo );
+      }
+
+      VkResult vkCopyAccelerationStructureToMemoryKHR( VkDevice                                           device,
+                                                       VkDeferredOperationKHR                             deferredOperation,
+                                                       const VkCopyAccelerationStructureToMemoryInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCopyAccelerationStructureToMemoryKHR( device, deferredOperation, pInfo );
+      }
+
+      VkResult vkCopyMemoryToAccelerationStructureKHR( VkDevice                                           device,
+                                                       VkDeferredOperationKHR                             deferredOperation,
+                                                       const VkCopyMemoryToAccelerationStructureInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCopyMemoryToAccelerationStructureKHR( device, deferredOperation, pInfo );
+      }
+
+      VkResult vkWriteAccelerationStructuresPropertiesKHR( VkDevice                           device,
+                                                           uint32_t                           accelerationStructureCount,
+                                                           const VkAccelerationStructureKHR * pAccelerationStructures,
+                                                           VkQueryType                        queryType,
+                                                           size_t                             dataSize,
+                                                           void *                             pData,
+                                                           size_t                             stride ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkWriteAccelerationStructuresPropertiesKHR( device, accelerationStructureCount, pAccelerationStructures, queryType, dataSize, pData, stride );
+      }
+
+      void vkCmdCopyAccelerationStructureKHR( VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdCopyAccelerationStructureKHR( commandBuffer, pInfo );
+      }
+
+      void vkCmdCopyAccelerationStructureToMemoryKHR( VkCommandBuffer                                    commandBuffer,
+                                                      const VkCopyAccelerationStructureToMemoryInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdCopyAccelerationStructureToMemoryKHR( commandBuffer, pInfo );
+      }
+
+      void vkCmdCopyMemoryToAccelerationStructureKHR( VkCommandBuffer                                    commandBuffer,
+                                                      const VkCopyMemoryToAccelerationStructureInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdCopyMemoryToAccelerationStructureKHR( commandBuffer, pInfo );
+      }
+
+      VkDeviceAddress vkGetAccelerationStructureDeviceAddressKHR( VkDevice                                            device,
+                                                                  const VkAccelerationStructureDeviceAddressInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetAccelerationStructureDeviceAddressKHR( device, pInfo );
+      }
+
+      void vkCmdWriteAccelerationStructuresPropertiesKHR( VkCommandBuffer                    commandBuffer,
+                                                          uint32_t                           accelerationStructureCount,
+                                                          const VkAccelerationStructureKHR * pAccelerationStructures,
+                                                          VkQueryType                        queryType,
+                                                          VkQueryPool                        queryPool,
+                                                          uint32_t                           firstQuery ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdWriteAccelerationStructuresPropertiesKHR(
+          commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery );
+      }
+
+      void vkGetDeviceAccelerationStructureCompatibilityKHR( VkDevice                                      device,
+                                                             const VkAccelerationStructureVersionInfoKHR * pVersionInfo,
+                                                             VkAccelerationStructureCompatibilityKHR *     pCompatibility ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetDeviceAccelerationStructureCompatibilityKHR( device, pVersionInfo, pCompatibility );
+      }
+
+      void vkGetAccelerationStructureBuildSizesKHR( VkDevice                                            device,
+                                                    VkAccelerationStructureBuildTypeKHR                 buildType,
+                                                    const VkAccelerationStructureBuildGeometryInfoKHR * pBuildInfo,
+                                                    const uint32_t *                                    pMaxPrimitiveCounts,
+                                                    VkAccelerationStructureBuildSizesInfoKHR *          pSizeInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetAccelerationStructureBuildSizesKHR( device, buildType, pBuildInfo, pMaxPrimitiveCounts, pSizeInfo );
+      }
+
+      //=== VK_KHR_ray_tracing_pipeline ===
+
+      void vkCmdTraceRaysKHR( VkCommandBuffer                         commandBuffer,
+                              const VkStridedDeviceAddressRegionKHR * pRaygenShaderBindingTable,
+                              const VkStridedDeviceAddressRegionKHR * pMissShaderBindingTable,
+                              const VkStridedDeviceAddressRegionKHR * pHitShaderBindingTable,
+                              const VkStridedDeviceAddressRegionKHR * pCallableShaderBindingTable,
+                              uint32_t                                width,
+                              uint32_t                                height,
+                              uint32_t                                depth ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdTraceRaysKHR(
+          commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, width, height, depth );
+      }
+
+      VkResult vkCreateRayTracingPipelinesKHR( VkDevice                                  device,
+                                               VkDeferredOperationKHR                    deferredOperation,
+                                               VkPipelineCache                           pipelineCache,
+                                               uint32_t                                  createInfoCount,
+                                               const VkRayTracingPipelineCreateInfoKHR * pCreateInfos,
+                                               const VkAllocationCallbacks *             pAllocator,
+                                               VkPipeline *                              pPipelines ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateRayTracingPipelinesKHR( device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines );
+      }
+
+      VkResult vkGetRayTracingShaderGroupHandlesKHR(
+        VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void * pData ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetRayTracingShaderGroupHandlesKHR( device, pipeline, firstGroup, groupCount, dataSize, pData );
+      }
+
+      VkResult vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(
+        VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void * pData ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( device, pipeline, firstGroup, groupCount, dataSize, pData );
+      }
+
+      void vkCmdTraceRaysIndirectKHR( VkCommandBuffer                         commandBuffer,
+                                      const VkStridedDeviceAddressRegionKHR * pRaygenShaderBindingTable,
+                                      const VkStridedDeviceAddressRegionKHR * pMissShaderBindingTable,
+                                      const VkStridedDeviceAddressRegionKHR * pHitShaderBindingTable,
+                                      const VkStridedDeviceAddressRegionKHR * pCallableShaderBindingTable,
+                                      VkDeviceAddress                         indirectDeviceAddress ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdTraceRaysIndirectKHR(
+          commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, indirectDeviceAddress );
+      }
+
+      VkDeviceSize vkGetRayTracingShaderGroupStackSizeKHR( VkDevice               device,
+                                                           VkPipeline             pipeline,
+                                                           uint32_t               group,
+                                                           VkShaderGroupShaderKHR groupShader ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetRayTracingShaderGroupStackSizeKHR( device, pipeline, group, groupShader );
+      }
+
+      void vkCmdSetRayTracingPipelineStackSizeKHR( VkCommandBuffer commandBuffer, uint32_t pipelineStackSize ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetRayTracingPipelineStackSizeKHR( commandBuffer, pipelineStackSize );
+      }
+
+      //=== VK_KHR_sampler_ycbcr_conversion ===
+
+      VkResult vkCreateSamplerYcbcrConversionKHR( VkDevice                                   device,
+                                                  const VkSamplerYcbcrConversionCreateInfo * pCreateInfo,
+                                                  const VkAllocationCallbacks *              pAllocator,
+                                                  VkSamplerYcbcrConversion *                 pYcbcrConversion ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateSamplerYcbcrConversionKHR( device, pCreateInfo, pAllocator, pYcbcrConversion );
+      }
+
+      void vkDestroySamplerYcbcrConversionKHR( VkDevice                      device,
+                                               VkSamplerYcbcrConversion      ycbcrConversion,
+                                               const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkDestroySamplerYcbcrConversionKHR( device, ycbcrConversion, pAllocator );
+      }
+
+      //=== VK_KHR_bind_memory2 ===
+
+      VkResult vkBindBufferMemory2KHR( VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo * pBindInfos ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkBindBufferMemory2KHR( device, bindInfoCount, pBindInfos );
+      }
+
+      VkResult vkBindImageMemory2KHR( VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo * pBindInfos ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkBindImageMemory2KHR( device, bindInfoCount, pBindInfos );
+      }
+
+      //=== VK_EXT_image_drm_format_modifier ===
+
+      VkResult vkGetImageDrmFormatModifierPropertiesEXT( VkDevice                                device,
+                                                         VkImage                                 image,
+                                                         VkImageDrmFormatModifierPropertiesEXT * pProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetImageDrmFormatModifierPropertiesEXT( device, image, pProperties );
+      }
+
+      //=== VK_EXT_validation_cache ===
+
+      VkResult vkCreateValidationCacheEXT( VkDevice                               device,
+                                           const VkValidationCacheCreateInfoEXT * pCreateInfo,
+                                           const VkAllocationCallbacks *          pAllocator,
+                                           VkValidationCacheEXT *                 pValidationCache ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateValidationCacheEXT( device, pCreateInfo, pAllocator, pValidationCache );
+      }
+
+      void
+        vkDestroyValidationCacheEXT( VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkDestroyValidationCacheEXT( device, validationCache, pAllocator );
+      }
+
+      VkResult vkMergeValidationCachesEXT( VkDevice                     device,
+                                           VkValidationCacheEXT         dstCache,
+                                           uint32_t                     srcCacheCount,
+                                           const VkValidationCacheEXT * pSrcCaches ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkMergeValidationCachesEXT( device, dstCache, srcCacheCount, pSrcCaches );
+      }
+
+      VkResult vkGetValidationCacheDataEXT( VkDevice device, VkValidationCacheEXT validationCache, size_t * pDataSize, void * pData ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetValidationCacheDataEXT( device, validationCache, pDataSize, pData );
+      }
+
+      //=== VK_NV_shading_rate_image ===
+
+      void vkCmdBindShadingRateImageNV( VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdBindShadingRateImageNV( commandBuffer, imageView, imageLayout );
+      }
+
+      void vkCmdSetViewportShadingRatePaletteNV( VkCommandBuffer                commandBuffer,
+                                                 uint32_t                       firstViewport,
+                                                 uint32_t                       viewportCount,
+                                                 const VkShadingRatePaletteNV * pShadingRatePalettes ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetViewportShadingRatePaletteNV( commandBuffer, firstViewport, viewportCount, pShadingRatePalettes );
+      }
+
+      void vkCmdSetCoarseSampleOrderNV( VkCommandBuffer                     commandBuffer,
+                                        VkCoarseSampleOrderTypeNV           sampleOrderType,
+                                        uint32_t                            customSampleOrderCount,
+                                        const VkCoarseSampleOrderCustomNV * pCustomSampleOrders ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetCoarseSampleOrderNV( commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders );
+      }
+
+      //=== VK_NV_ray_tracing ===
+
+      VkResult vkCreateAccelerationStructureNV( VkDevice                                    device,
+                                                const VkAccelerationStructureCreateInfoNV * pCreateInfo,
+                                                const VkAllocationCallbacks *               pAllocator,
+                                                VkAccelerationStructureNV *                 pAccelerationStructure ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateAccelerationStructureNV( device, pCreateInfo, pAllocator, pAccelerationStructure );
+      }
+
+      void vkDestroyAccelerationStructureNV( VkDevice                      device,
+                                             VkAccelerationStructureNV     accelerationStructure,
+                                             const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkDestroyAccelerationStructureNV( device, accelerationStructure, pAllocator );
+      }
+
+      void vkGetAccelerationStructureMemoryRequirementsNV( VkDevice                                                device,
+                                                           const VkAccelerationStructureMemoryRequirementsInfoNV * pInfo,
+                                                           VkMemoryRequirements2KHR * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetAccelerationStructureMemoryRequirementsNV( device, pInfo, pMemoryRequirements );
+      }
+
+      VkResult vkBindAccelerationStructureMemoryNV( VkDevice                                        device,
+                                                    uint32_t                                        bindInfoCount,
+                                                    const VkBindAccelerationStructureMemoryInfoNV * pBindInfos ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkBindAccelerationStructureMemoryNV( device, bindInfoCount, pBindInfos );
+      }
+
+      void vkCmdBuildAccelerationStructureNV( VkCommandBuffer                       commandBuffer,
+                                              const VkAccelerationStructureInfoNV * pInfo,
+                                              VkBuffer                              instanceData,
+                                              VkDeviceSize                          instanceOffset,
+                                              VkBool32                              update,
+                                              VkAccelerationStructureNV             dst,
+                                              VkAccelerationStructureNV             src,
+                                              VkBuffer                              scratch,
+                                              VkDeviceSize                          scratchOffset ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdBuildAccelerationStructureNV( commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset );
+      }
+
+      void vkCmdCopyAccelerationStructureNV( VkCommandBuffer                    commandBuffer,
+                                             VkAccelerationStructureNV          dst,
+                                             VkAccelerationStructureNV          src,
+                                             VkCopyAccelerationStructureModeKHR mode ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdCopyAccelerationStructureNV( commandBuffer, dst, src, mode );
+      }
+
+      void vkCmdTraceRaysNV( VkCommandBuffer commandBuffer,
+                             VkBuffer        raygenShaderBindingTableBuffer,
+                             VkDeviceSize    raygenShaderBindingOffset,
+                             VkBuffer        missShaderBindingTableBuffer,
+                             VkDeviceSize    missShaderBindingOffset,
+                             VkDeviceSize    missShaderBindingStride,
+                             VkBuffer        hitShaderBindingTableBuffer,
+                             VkDeviceSize    hitShaderBindingOffset,
+                             VkDeviceSize    hitShaderBindingStride,
+                             VkBuffer        callableShaderBindingTableBuffer,
+                             VkDeviceSize    callableShaderBindingOffset,
+                             VkDeviceSize    callableShaderBindingStride,
+                             uint32_t        width,
+                             uint32_t        height,
+                             uint32_t        depth ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdTraceRaysNV( commandBuffer,
+                                   raygenShaderBindingTableBuffer,
+                                   raygenShaderBindingOffset,
+                                   missShaderBindingTableBuffer,
+                                   missShaderBindingOffset,
+                                   missShaderBindingStride,
+                                   hitShaderBindingTableBuffer,
+                                   hitShaderBindingOffset,
+                                   hitShaderBindingStride,
+                                   callableShaderBindingTableBuffer,
+                                   callableShaderBindingOffset,
+                                   callableShaderBindingStride,
+                                   width,
+                                   height,
+                                   depth );
+      }
+
+      VkResult vkCreateRayTracingPipelinesNV( VkDevice                                 device,
+                                              VkPipelineCache                          pipelineCache,
+                                              uint32_t                                 createInfoCount,
+                                              const VkRayTracingPipelineCreateInfoNV * pCreateInfos,
+                                              const VkAllocationCallbacks *            pAllocator,
+                                              VkPipeline *                             pPipelines ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateRayTracingPipelinesNV( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines );
+      }
+
+      VkResult vkGetRayTracingShaderGroupHandlesNV(
+        VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void * pData ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetRayTracingShaderGroupHandlesNV( device, pipeline, firstGroup, groupCount, dataSize, pData );
+      }
+
+      VkResult vkGetAccelerationStructureHandleNV( VkDevice                  device,
+                                                   VkAccelerationStructureNV accelerationStructure,
+                                                   size_t                    dataSize,
+                                                   void *                    pData ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetAccelerationStructureHandleNV( device, accelerationStructure, dataSize, pData );
+      }
+
+      void vkCmdWriteAccelerationStructuresPropertiesNV( VkCommandBuffer                   commandBuffer,
+                                                         uint32_t                          accelerationStructureCount,
+                                                         const VkAccelerationStructureNV * pAccelerationStructures,
+                                                         VkQueryType                       queryType,
+                                                         VkQueryPool                       queryPool,
+                                                         uint32_t                          firstQuery ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdWriteAccelerationStructuresPropertiesNV(
+          commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery );
+      }
+
+      VkResult vkCompileDeferredNV( VkDevice device, VkPipeline pipeline, uint32_t shader ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCompileDeferredNV( device, pipeline, shader );
+      }
+
+      //=== VK_KHR_maintenance3 ===
+
+      void vkGetDescriptorSetLayoutSupportKHR( VkDevice                                device,
+                                               const VkDescriptorSetLayoutCreateInfo * pCreateInfo,
+                                               VkDescriptorSetLayoutSupport *          pSupport ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetDescriptorSetLayoutSupportKHR( device, pCreateInfo, pSupport );
+      }
+
+      //=== VK_KHR_draw_indirect_count ===
+
+      void vkCmdDrawIndirectCountKHR( VkCommandBuffer commandBuffer,
+                                      VkBuffer        buffer,
+                                      VkDeviceSize    offset,
+                                      VkBuffer        countBuffer,
+                                      VkDeviceSize    countBufferOffset,
+                                      uint32_t        maxDrawCount,
+                                      uint32_t        stride ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdDrawIndirectCountKHR( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
+      }
+
+      void vkCmdDrawIndexedIndirectCountKHR( VkCommandBuffer commandBuffer,
+                                             VkBuffer        buffer,
+                                             VkDeviceSize    offset,
+                                             VkBuffer        countBuffer,
+                                             VkDeviceSize    countBufferOffset,
+                                             uint32_t        maxDrawCount,
+                                             uint32_t        stride ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdDrawIndexedIndirectCountKHR( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
+      }
+
+      //=== VK_EXT_external_memory_host ===
+
+      VkResult vkGetMemoryHostPointerPropertiesEXT( VkDevice                           device,
+                                                    VkExternalMemoryHandleTypeFlagBits handleType,
+                                                    const void *                       pHostPointer,
+                                                    VkMemoryHostPointerPropertiesEXT * pMemoryHostPointerProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetMemoryHostPointerPropertiesEXT( device, handleType, pHostPointer, pMemoryHostPointerProperties );
+      }
+
+      //=== VK_AMD_buffer_marker ===
+
+      void vkCmdWriteBufferMarkerAMD( VkCommandBuffer         commandBuffer,
+                                      VkPipelineStageFlagBits pipelineStage,
+                                      VkBuffer                dstBuffer,
+                                      VkDeviceSize            dstOffset,
+                                      uint32_t                marker ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdWriteBufferMarkerAMD( commandBuffer, pipelineStage, dstBuffer, dstOffset, marker );
+      }
+
+      void vkCmdWriteBufferMarker2AMD(
+        VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdWriteBufferMarker2AMD( commandBuffer, stage, dstBuffer, dstOffset, marker );
+      }
+
+      //=== VK_EXT_calibrated_timestamps ===
+
+      VkResult vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( VkPhysicalDevice  physicalDevice,
+                                                               uint32_t *        pTimeDomainCount,
+                                                               VkTimeDomainKHR * pTimeDomains ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( physicalDevice, pTimeDomainCount, pTimeDomains );
+      }
+
+      VkResult vkGetCalibratedTimestampsEXT( VkDevice                             device,
+                                             uint32_t                             timestampCount,
+                                             const VkCalibratedTimestampInfoKHR * pTimestampInfos,
+                                             uint64_t *                           pTimestamps,
+                                             uint64_t *                           pMaxDeviation ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetCalibratedTimestampsEXT( device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation );
+      }
+
+      //=== VK_NV_mesh_shader ===
+
+      void vkCmdDrawMeshTasksNV( VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdDrawMeshTasksNV( commandBuffer, taskCount, firstTask );
+      }
+
+      void vkCmdDrawMeshTasksIndirectNV( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride ) const
+        VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdDrawMeshTasksIndirectNV( commandBuffer, buffer, offset, drawCount, stride );
+      }
+
+      void vkCmdDrawMeshTasksIndirectCountNV( VkCommandBuffer commandBuffer,
+                                              VkBuffer        buffer,
+                                              VkDeviceSize    offset,
+                                              VkBuffer        countBuffer,
+                                              VkDeviceSize    countBufferOffset,
+                                              uint32_t        maxDrawCount,
+                                              uint32_t        stride ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdDrawMeshTasksIndirectCountNV( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
+      }
+
+      //=== VK_NV_scissor_exclusive ===
+
+      void vkCmdSetExclusiveScissorEnableNV( VkCommandBuffer  commandBuffer,
+                                             uint32_t         firstExclusiveScissor,
+                                             uint32_t         exclusiveScissorCount,
+                                             const VkBool32 * pExclusiveScissorEnables ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetExclusiveScissorEnableNV( commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissorEnables );
+      }
+
+      void vkCmdSetExclusiveScissorNV( VkCommandBuffer  commandBuffer,
+                                       uint32_t         firstExclusiveScissor,
+                                       uint32_t         exclusiveScissorCount,
+                                       const VkRect2D * pExclusiveScissors ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetExclusiveScissorNV( commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors );
+      }
+
+      //=== VK_NV_device_diagnostic_checkpoints ===
+
+      void vkCmdSetCheckpointNV( VkCommandBuffer commandBuffer, const void * pCheckpointMarker ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetCheckpointNV( commandBuffer, pCheckpointMarker );
+      }
+
+      void vkGetQueueCheckpointDataNV( VkQueue queue, uint32_t * pCheckpointDataCount, VkCheckpointDataNV * pCheckpointData ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetQueueCheckpointDataNV( queue, pCheckpointDataCount, pCheckpointData );
+      }
+
+      void vkGetQueueCheckpointData2NV( VkQueue queue, uint32_t * pCheckpointDataCount, VkCheckpointData2NV * pCheckpointData ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetQueueCheckpointData2NV( queue, pCheckpointDataCount, pCheckpointData );
+      }
+
+      //=== VK_KHR_timeline_semaphore ===
+
+      VkResult vkGetSemaphoreCounterValueKHR( VkDevice device, VkSemaphore semaphore, uint64_t * pValue ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetSemaphoreCounterValueKHR( device, semaphore, pValue );
+      }
+
+      VkResult vkWaitSemaphoresKHR( VkDevice device, const VkSemaphoreWaitInfo * pWaitInfo, uint64_t timeout ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkWaitSemaphoresKHR( device, pWaitInfo, timeout );
+      }
+
+      VkResult vkSignalSemaphoreKHR( VkDevice device, const VkSemaphoreSignalInfo * pSignalInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkSignalSemaphoreKHR( device, pSignalInfo );
+      }
+
+      //=== VK_INTEL_performance_query ===
+
+      VkResult vkInitializePerformanceApiINTEL( VkDevice device, const VkInitializePerformanceApiInfoINTEL * pInitializeInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkInitializePerformanceApiINTEL( device, pInitializeInfo );
+      }
+
+      void vkUninitializePerformanceApiINTEL( VkDevice device ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkUninitializePerformanceApiINTEL( device );
+      }
+
+      VkResult vkCmdSetPerformanceMarkerINTEL( VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL * pMarkerInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetPerformanceMarkerINTEL( commandBuffer, pMarkerInfo );
+      }
+
+      VkResult vkCmdSetPerformanceStreamMarkerINTEL( VkCommandBuffer                            commandBuffer,
+                                                     const VkPerformanceStreamMarkerInfoINTEL * pMarkerInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetPerformanceStreamMarkerINTEL( commandBuffer, pMarkerInfo );
+      }
+
+      VkResult vkCmdSetPerformanceOverrideINTEL( VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL * pOverrideInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetPerformanceOverrideINTEL( commandBuffer, pOverrideInfo );
+      }
+
+      VkResult vkAcquirePerformanceConfigurationINTEL( VkDevice                                           device,
+                                                       const VkPerformanceConfigurationAcquireInfoINTEL * pAcquireInfo,
+                                                       VkPerformanceConfigurationINTEL *                  pConfiguration ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkAcquirePerformanceConfigurationINTEL( device, pAcquireInfo, pConfiguration );
+      }
+
+      VkResult vkReleasePerformanceConfigurationINTEL( VkDevice device, VkPerformanceConfigurationINTEL configuration ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkReleasePerformanceConfigurationINTEL( device, configuration );
+      }
+
+      VkResult vkQueueSetPerformanceConfigurationINTEL( VkQueue queue, VkPerformanceConfigurationINTEL configuration ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkQueueSetPerformanceConfigurationINTEL( queue, configuration );
+      }
+
+      VkResult
+        vkGetPerformanceParameterINTEL( VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL * pValue ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPerformanceParameterINTEL( device, parameter, pValue );
+      }
+
+      //=== VK_AMD_display_native_hdr ===
+
+      void vkSetLocalDimmingAMD( VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkSetLocalDimmingAMD( device, swapChain, localDimmingEnable );
+      }
+
+#  if defined( VK_USE_PLATFORM_FUCHSIA )
+      //=== VK_FUCHSIA_imagepipe_surface ===
+
+      VkResult vkCreateImagePipeSurfaceFUCHSIA( VkInstance                                  instance,
+                                                const VkImagePipeSurfaceCreateInfoFUCHSIA * pCreateInfo,
+                                                const VkAllocationCallbacks *               pAllocator,
+                                                VkSurfaceKHR *                              pSurface ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateImagePipeSurfaceFUCHSIA( instance, pCreateInfo, pAllocator, pSurface );
+      }
+#  endif /*VK_USE_PLATFORM_FUCHSIA*/
+
+#  if defined( VK_USE_PLATFORM_METAL_EXT )
+      //=== VK_EXT_metal_surface ===
+
+      VkResult vkCreateMetalSurfaceEXT( VkInstance                          instance,
+                                        const VkMetalSurfaceCreateInfoEXT * pCreateInfo,
+                                        const VkAllocationCallbacks *       pAllocator,
+                                        VkSurfaceKHR *                      pSurface ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateMetalSurfaceEXT( instance, pCreateInfo, pAllocator, pSurface );
+      }
+#  endif /*VK_USE_PLATFORM_METAL_EXT*/
+
+      //=== VK_KHR_fragment_shading_rate ===
+
+      VkResult vkGetPhysicalDeviceFragmentShadingRatesKHR( VkPhysicalDevice                         physicalDevice,
+                                                           uint32_t *                               pFragmentShadingRateCount,
+                                                           VkPhysicalDeviceFragmentShadingRateKHR * pFragmentShadingRates ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceFragmentShadingRatesKHR( physicalDevice, pFragmentShadingRateCount, pFragmentShadingRates );
+      }
+
+      void vkCmdSetFragmentShadingRateKHR( VkCommandBuffer                          commandBuffer,
+                                           const VkExtent2D *                       pFragmentSize,
+                                           const VkFragmentShadingRateCombinerOpKHR combinerOps[2] ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetFragmentShadingRateKHR( commandBuffer, pFragmentSize, combinerOps );
+      }
+
+      //=== VK_KHR_dynamic_rendering_local_read ===
+
+      void vkCmdSetRenderingAttachmentLocationsKHR( VkCommandBuffer                              commandBuffer,
+                                                    const VkRenderingAttachmentLocationInfoKHR * pLocationInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetRenderingAttachmentLocationsKHR( commandBuffer, pLocationInfo );
+      }
+
+      void vkCmdSetRenderingInputAttachmentIndicesKHR( VkCommandBuffer                                commandBuffer,
+                                                       const VkRenderingInputAttachmentIndexInfoKHR * pInputAttachmentIndexInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetRenderingInputAttachmentIndicesKHR( commandBuffer, pInputAttachmentIndexInfo );
+      }
+
+      //=== VK_EXT_buffer_device_address ===
+
+      VkDeviceAddress vkGetBufferDeviceAddressEXT( VkDevice device, const VkBufferDeviceAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetBufferDeviceAddressEXT( device, pInfo );
+      }
+
+      //=== VK_EXT_tooling_info ===
+
+      VkResult vkGetPhysicalDeviceToolPropertiesEXT( VkPhysicalDevice                 physicalDevice,
+                                                     uint32_t *                       pToolCount,
+                                                     VkPhysicalDeviceToolProperties * pToolProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceToolPropertiesEXT( physicalDevice, pToolCount, pToolProperties );
+      }
+
+      //=== VK_KHR_present_wait ===
+
+      VkResult vkWaitForPresentKHR( VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkWaitForPresentKHR( device, swapchain, presentId, timeout );
+      }
+
+      //=== VK_NV_cooperative_matrix ===
+
+      VkResult vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( VkPhysicalDevice                  physicalDevice,
+                                                                 uint32_t *                        pPropertyCount,
+                                                                 VkCooperativeMatrixPropertiesNV * pProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( physicalDevice, pPropertyCount, pProperties );
+      }
+
+      //=== VK_NV_coverage_reduction_mode ===
+
+      VkResult vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
+        VkPhysicalDevice physicalDevice, uint32_t * pCombinationCount, VkFramebufferMixedSamplesCombinationNV * pCombinations ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( physicalDevice, pCombinationCount, pCombinations );
+      }
+
+#  if defined( VK_USE_PLATFORM_WIN32_KHR )
+      //=== VK_EXT_full_screen_exclusive ===
+
+      VkResult vkGetPhysicalDeviceSurfacePresentModes2EXT( VkPhysicalDevice                        physicalDevice,
+                                                           const VkPhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
+                                                           uint32_t *                              pPresentModeCount,
+                                                           VkPresentModeKHR *                      pPresentModes ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceSurfacePresentModes2EXT( physicalDevice, pSurfaceInfo, pPresentModeCount, pPresentModes );
+      }
+
+      VkResult vkAcquireFullScreenExclusiveModeEXT( VkDevice device, VkSwapchainKHR swapchain ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkAcquireFullScreenExclusiveModeEXT( device, swapchain );
+      }
+
+      VkResult vkReleaseFullScreenExclusiveModeEXT( VkDevice device, VkSwapchainKHR swapchain ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkReleaseFullScreenExclusiveModeEXT( device, swapchain );
+      }
+
+      VkResult vkGetDeviceGroupSurfacePresentModes2EXT( VkDevice                                device,
+                                                        const VkPhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
+                                                        VkDeviceGroupPresentModeFlagsKHR *      pModes ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetDeviceGroupSurfacePresentModes2EXT( device, pSurfaceInfo, pModes );
+      }
+#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+      //=== VK_EXT_headless_surface ===
+
+      VkResult vkCreateHeadlessSurfaceEXT( VkInstance                             instance,
+                                           const VkHeadlessSurfaceCreateInfoEXT * pCreateInfo,
+                                           const VkAllocationCallbacks *          pAllocator,
+                                           VkSurfaceKHR *                         pSurface ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateHeadlessSurfaceEXT( instance, pCreateInfo, pAllocator, pSurface );
+      }
+
+      //=== VK_KHR_buffer_device_address ===
+
+      VkDeviceAddress vkGetBufferDeviceAddressKHR( VkDevice device, const VkBufferDeviceAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetBufferDeviceAddressKHR( device, pInfo );
+      }
+
+      uint64_t vkGetBufferOpaqueCaptureAddressKHR( VkDevice device, const VkBufferDeviceAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetBufferOpaqueCaptureAddressKHR( device, pInfo );
+      }
+
+      uint64_t vkGetDeviceMemoryOpaqueCaptureAddressKHR( VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetDeviceMemoryOpaqueCaptureAddressKHR( device, pInfo );
+      }
+
+      //=== VK_EXT_line_rasterization ===
+
+      void vkCmdSetLineStippleEXT( VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetLineStippleEXT( commandBuffer, lineStippleFactor, lineStipplePattern );
+      }
+
+      //=== VK_EXT_host_query_reset ===
+
+      void vkResetQueryPoolEXT( VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkResetQueryPoolEXT( device, queryPool, firstQuery, queryCount );
+      }
+
+      //=== VK_EXT_extended_dynamic_state ===
+
+      void vkCmdSetCullModeEXT( VkCommandBuffer commandBuffer, VkCullModeFlags cullMode ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetCullModeEXT( commandBuffer, cullMode );
+      }
+
+      void vkCmdSetFrontFaceEXT( VkCommandBuffer commandBuffer, VkFrontFace frontFace ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetFrontFaceEXT( commandBuffer, frontFace );
+      }
+
+      void vkCmdSetPrimitiveTopologyEXT( VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetPrimitiveTopologyEXT( commandBuffer, primitiveTopology );
+      }
+
+      void vkCmdSetViewportWithCountEXT( VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport * pViewports ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetViewportWithCountEXT( commandBuffer, viewportCount, pViewports );
+      }
+
+      void vkCmdSetScissorWithCountEXT( VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D * pScissors ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetScissorWithCountEXT( commandBuffer, scissorCount, pScissors );
+      }
+
+      void vkCmdBindVertexBuffers2EXT( VkCommandBuffer      commandBuffer,
+                                       uint32_t             firstBinding,
+                                       uint32_t             bindingCount,
+                                       const VkBuffer *     pBuffers,
+                                       const VkDeviceSize * pOffsets,
+                                       const VkDeviceSize * pSizes,
+                                       const VkDeviceSize * pStrides ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdBindVertexBuffers2EXT( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides );
+      }
+
+      void vkCmdSetDepthTestEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthTestEnable ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetDepthTestEnableEXT( commandBuffer, depthTestEnable );
+      }
+
+      void vkCmdSetDepthWriteEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetDepthWriteEnableEXT( commandBuffer, depthWriteEnable );
+      }
+
+      void vkCmdSetDepthCompareOpEXT( VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetDepthCompareOpEXT( commandBuffer, depthCompareOp );
+      }
+
+      void vkCmdSetDepthBoundsTestEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetDepthBoundsTestEnableEXT( commandBuffer, depthBoundsTestEnable );
+      }
+
+      void vkCmdSetStencilTestEnableEXT( VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetStencilTestEnableEXT( commandBuffer, stencilTestEnable );
+      }
+
+      void vkCmdSetStencilOpEXT( VkCommandBuffer    commandBuffer,
+                                 VkStencilFaceFlags faceMask,
+                                 VkStencilOp        failOp,
+                                 VkStencilOp        passOp,
+                                 VkStencilOp        depthFailOp,
+                                 VkCompareOp        compareOp ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetStencilOpEXT( commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp );
+      }
+
+      //=== VK_KHR_deferred_host_operations ===
+
+      VkResult vkCreateDeferredOperationKHR( VkDevice                      device,
+                                             const VkAllocationCallbacks * pAllocator,
+                                             VkDeferredOperationKHR *      pDeferredOperation ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateDeferredOperationKHR( device, pAllocator, pDeferredOperation );
+      }
+
+      void
+        vkDestroyDeferredOperationKHR( VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkDestroyDeferredOperationKHR( device, operation, pAllocator );
+      }
+
+      uint32_t vkGetDeferredOperationMaxConcurrencyKHR( VkDevice device, VkDeferredOperationKHR operation ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetDeferredOperationMaxConcurrencyKHR( device, operation );
+      }
+
+      VkResult vkGetDeferredOperationResultKHR( VkDevice device, VkDeferredOperationKHR operation ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetDeferredOperationResultKHR( device, operation );
+      }
+
+      VkResult vkDeferredOperationJoinKHR( VkDevice device, VkDeferredOperationKHR operation ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkDeferredOperationJoinKHR( device, operation );
+      }
+
+      //=== VK_KHR_pipeline_executable_properties ===
+
+      VkResult vkGetPipelineExecutablePropertiesKHR( VkDevice                            device,
+                                                     const VkPipelineInfoKHR *           pPipelineInfo,
+                                                     uint32_t *                          pExecutableCount,
+                                                     VkPipelineExecutablePropertiesKHR * pProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPipelineExecutablePropertiesKHR( device, pPipelineInfo, pExecutableCount, pProperties );
+      }
+
+      VkResult vkGetPipelineExecutableStatisticsKHR( VkDevice                            device,
+                                                     const VkPipelineExecutableInfoKHR * pExecutableInfo,
+                                                     uint32_t *                          pStatisticCount,
+                                                     VkPipelineExecutableStatisticKHR *  pStatistics ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPipelineExecutableStatisticsKHR( device, pExecutableInfo, pStatisticCount, pStatistics );
+      }
+
+      VkResult
+        vkGetPipelineExecutableInternalRepresentationsKHR( VkDevice                                        device,
+                                                           const VkPipelineExecutableInfoKHR *             pExecutableInfo,
+                                                           uint32_t *                                      pInternalRepresentationCount,
+                                                           VkPipelineExecutableInternalRepresentationKHR * pInternalRepresentations ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPipelineExecutableInternalRepresentationsKHR( device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations );
+      }
+
+      //=== VK_EXT_host_image_copy ===
+
+      VkResult vkCopyMemoryToImageEXT( VkDevice device, const VkCopyMemoryToImageInfoEXT * pCopyMemoryToImageInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCopyMemoryToImageEXT( device, pCopyMemoryToImageInfo );
+      }
+
+      VkResult vkCopyImageToMemoryEXT( VkDevice device, const VkCopyImageToMemoryInfoEXT * pCopyImageToMemoryInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCopyImageToMemoryEXT( device, pCopyImageToMemoryInfo );
+      }
+
+      VkResult vkCopyImageToImageEXT( VkDevice device, const VkCopyImageToImageInfoEXT * pCopyImageToImageInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCopyImageToImageEXT( device, pCopyImageToImageInfo );
+      }
+
+      VkResult vkTransitionImageLayoutEXT( VkDevice                                   device,
+                                           uint32_t                                   transitionCount,
+                                           const VkHostImageLayoutTransitionInfoEXT * pTransitions ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkTransitionImageLayoutEXT( device, transitionCount, pTransitions );
+      }
+
+      void vkGetImageSubresourceLayout2EXT( VkDevice                       device,
+                                            VkImage                        image,
+                                            const VkImageSubresource2KHR * pSubresource,
+                                            VkSubresourceLayout2KHR *      pLayout ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetImageSubresourceLayout2EXT( device, image, pSubresource, pLayout );
+      }
+
+      //=== VK_KHR_map_memory2 ===
+
+      VkResult vkMapMemory2KHR( VkDevice device, const VkMemoryMapInfoKHR * pMemoryMapInfo, void ** ppData ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkMapMemory2KHR( device, pMemoryMapInfo, ppData );
+      }
+
+      VkResult vkUnmapMemory2KHR( VkDevice device, const VkMemoryUnmapInfoKHR * pMemoryUnmapInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkUnmapMemory2KHR( device, pMemoryUnmapInfo );
+      }
+
+      //=== VK_EXT_swapchain_maintenance1 ===
+
+      VkResult vkReleaseSwapchainImagesEXT( VkDevice device, const VkReleaseSwapchainImagesInfoEXT * pReleaseInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkReleaseSwapchainImagesEXT( device, pReleaseInfo );
+      }
+
+      //=== VK_NV_device_generated_commands ===
+
+      void vkGetGeneratedCommandsMemoryRequirementsNV( VkDevice                                            device,
+                                                       const VkGeneratedCommandsMemoryRequirementsInfoNV * pInfo,
+                                                       VkMemoryRequirements2 *                             pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetGeneratedCommandsMemoryRequirementsNV( device, pInfo, pMemoryRequirements );
+      }
+
+      void vkCmdPreprocessGeneratedCommandsNV( VkCommandBuffer                   commandBuffer,
+                                               const VkGeneratedCommandsInfoNV * pGeneratedCommandsInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdPreprocessGeneratedCommandsNV( commandBuffer, pGeneratedCommandsInfo );
+      }
+
+      void vkCmdExecuteGeneratedCommandsNV( VkCommandBuffer                   commandBuffer,
+                                            VkBool32                          isPreprocessed,
+                                            const VkGeneratedCommandsInfoNV * pGeneratedCommandsInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdExecuteGeneratedCommandsNV( commandBuffer, isPreprocessed, pGeneratedCommandsInfo );
+      }
+
+      void vkCmdBindPipelineShaderGroupNV( VkCommandBuffer     commandBuffer,
+                                           VkPipelineBindPoint pipelineBindPoint,
+                                           VkPipeline          pipeline,
+                                           uint32_t            groupIndex ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdBindPipelineShaderGroupNV( commandBuffer, pipelineBindPoint, pipeline, groupIndex );
+      }
+
+      VkResult vkCreateIndirectCommandsLayoutNV( VkDevice                                     device,
+                                                 const VkIndirectCommandsLayoutCreateInfoNV * pCreateInfo,
+                                                 const VkAllocationCallbacks *                pAllocator,
+                                                 VkIndirectCommandsLayoutNV *                 pIndirectCommandsLayout ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateIndirectCommandsLayoutNV( device, pCreateInfo, pAllocator, pIndirectCommandsLayout );
+      }
+
+      void vkDestroyIndirectCommandsLayoutNV( VkDevice                      device,
+                                              VkIndirectCommandsLayoutNV    indirectCommandsLayout,
+                                              const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkDestroyIndirectCommandsLayoutNV( device, indirectCommandsLayout, pAllocator );
+      }
+
+      //=== VK_EXT_depth_bias_control ===
+
+      void vkCmdSetDepthBias2EXT( VkCommandBuffer commandBuffer, const VkDepthBiasInfoEXT * pDepthBiasInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetDepthBias2EXT( commandBuffer, pDepthBiasInfo );
+      }
+
+      //=== VK_EXT_acquire_drm_display ===
+
+      VkResult vkAcquireDrmDisplayEXT( VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkAcquireDrmDisplayEXT( physicalDevice, drmFd, display );
+      }
+
+      VkResult vkGetDrmDisplayEXT( VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId, VkDisplayKHR * display ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetDrmDisplayEXT( physicalDevice, drmFd, connectorId, display );
+      }
+
+      //=== VK_EXT_private_data ===
+
+      VkResult vkCreatePrivateDataSlotEXT( VkDevice                            device,
+                                           const VkPrivateDataSlotCreateInfo * pCreateInfo,
+                                           const VkAllocationCallbacks *       pAllocator,
+                                           VkPrivateDataSlot *                 pPrivateDataSlot ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreatePrivateDataSlotEXT( device, pCreateInfo, pAllocator, pPrivateDataSlot );
+      }
+
+      void vkDestroyPrivateDataSlotEXT( VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkDestroyPrivateDataSlotEXT( device, privateDataSlot, pAllocator );
+      }
+
+      VkResult vkSetPrivateDataEXT( VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data ) const
+        VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkSetPrivateDataEXT( device, objectType, objectHandle, privateDataSlot, data );
+      }
+
+      void vkGetPrivateDataEXT( VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t * pData ) const
+        VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPrivateDataEXT( device, objectType, objectHandle, privateDataSlot, pData );
+      }
+
+      //=== VK_KHR_video_encode_queue ===
+
+      VkResult
+        vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( VkPhysicalDevice                                       physicalDevice,
+                                                                 const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR * pQualityLevelInfo,
+                                                                 VkVideoEncodeQualityLevelPropertiesKHR * pQualityLevelProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( physicalDevice, pQualityLevelInfo, pQualityLevelProperties );
+      }
+
+      VkResult vkGetEncodedVideoSessionParametersKHR( VkDevice                                         device,
+                                                      const VkVideoEncodeSessionParametersGetInfoKHR * pVideoSessionParametersInfo,
+                                                      VkVideoEncodeSessionParametersFeedbackInfoKHR *  pFeedbackInfo,
+                                                      size_t *                                         pDataSize,
+                                                      void *                                           pData ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetEncodedVideoSessionParametersKHR( device, pVideoSessionParametersInfo, pFeedbackInfo, pDataSize, pData );
+      }
+
+      void vkCmdEncodeVideoKHR( VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR * pEncodeInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdEncodeVideoKHR( commandBuffer, pEncodeInfo );
+      }
+
+#  if defined( VK_ENABLE_BETA_EXTENSIONS )
+      //=== VK_NV_cuda_kernel_launch ===
+
+      VkResult vkCreateCudaModuleNV( VkDevice                         device,
+                                     const VkCudaModuleCreateInfoNV * pCreateInfo,
+                                     const VkAllocationCallbacks *    pAllocator,
+                                     VkCudaModuleNV *                 pModule ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateCudaModuleNV( device, pCreateInfo, pAllocator, pModule );
+      }
+
+      VkResult vkGetCudaModuleCacheNV( VkDevice device, VkCudaModuleNV module, size_t * pCacheSize, void * pCacheData ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetCudaModuleCacheNV( device, module, pCacheSize, pCacheData );
+      }
+
+      VkResult vkCreateCudaFunctionNV( VkDevice                           device,
+                                       const VkCudaFunctionCreateInfoNV * pCreateInfo,
+                                       const VkAllocationCallbacks *      pAllocator,
+                                       VkCudaFunctionNV *                 pFunction ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateCudaFunctionNV( device, pCreateInfo, pAllocator, pFunction );
+      }
+
+      void vkDestroyCudaModuleNV( VkDevice device, VkCudaModuleNV module, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkDestroyCudaModuleNV( device, module, pAllocator );
+      }
+
+      void vkDestroyCudaFunctionNV( VkDevice device, VkCudaFunctionNV function, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkDestroyCudaFunctionNV( device, function, pAllocator );
+      }
+
+      void vkCmdCudaLaunchKernelNV( VkCommandBuffer commandBuffer, const VkCudaLaunchInfoNV * pLaunchInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdCudaLaunchKernelNV( commandBuffer, pLaunchInfo );
+      }
+#  endif /*VK_ENABLE_BETA_EXTENSIONS*/
+
+#  if defined( VK_USE_PLATFORM_METAL_EXT )
+      //=== VK_EXT_metal_objects ===
+
+      void vkExportMetalObjectsEXT( VkDevice device, VkExportMetalObjectsInfoEXT * pMetalObjectsInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkExportMetalObjectsEXT( device, pMetalObjectsInfo );
+      }
+#  endif /*VK_USE_PLATFORM_METAL_EXT*/
+
+      //=== VK_KHR_synchronization2 ===
+
+      void vkCmdSetEvent2KHR( VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo * pDependencyInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetEvent2KHR( commandBuffer, event, pDependencyInfo );
+      }
+
+      void vkCmdResetEvent2KHR( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdResetEvent2KHR( commandBuffer, event, stageMask );
+      }
+
+      void vkCmdWaitEvents2KHR( VkCommandBuffer          commandBuffer,
+                                uint32_t                 eventCount,
+                                const VkEvent *          pEvents,
+                                const VkDependencyInfo * pDependencyInfos ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdWaitEvents2KHR( commandBuffer, eventCount, pEvents, pDependencyInfos );
+      }
+
+      void vkCmdPipelineBarrier2KHR( VkCommandBuffer commandBuffer, const VkDependencyInfo * pDependencyInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdPipelineBarrier2KHR( commandBuffer, pDependencyInfo );
+      }
+
+      void
+        vkCmdWriteTimestamp2KHR( VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdWriteTimestamp2KHR( commandBuffer, stage, queryPool, query );
+      }
+
+      VkResult vkQueueSubmit2KHR( VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 * pSubmits, VkFence fence ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkQueueSubmit2KHR( queue, submitCount, pSubmits, fence );
+      }
+
+      //=== VK_EXT_descriptor_buffer ===
+
+      void vkGetDescriptorSetLayoutSizeEXT( VkDevice device, VkDescriptorSetLayout layout, VkDeviceSize * pLayoutSizeInBytes ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetDescriptorSetLayoutSizeEXT( device, layout, pLayoutSizeInBytes );
+      }
+
+      void vkGetDescriptorSetLayoutBindingOffsetEXT( VkDevice              device,
+                                                     VkDescriptorSetLayout layout,
+                                                     uint32_t              binding,
+                                                     VkDeviceSize *        pOffset ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetDescriptorSetLayoutBindingOffsetEXT( device, layout, binding, pOffset );
+      }
+
+      void vkGetDescriptorEXT( VkDevice device, const VkDescriptorGetInfoEXT * pDescriptorInfo, size_t dataSize, void * pDescriptor ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetDescriptorEXT( device, pDescriptorInfo, dataSize, pDescriptor );
+      }
+
+      void vkCmdBindDescriptorBuffersEXT( VkCommandBuffer                          commandBuffer,
+                                          uint32_t                                 bufferCount,
+                                          const VkDescriptorBufferBindingInfoEXT * pBindingInfos ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdBindDescriptorBuffersEXT( commandBuffer, bufferCount, pBindingInfos );
+      }
+
+      void vkCmdSetDescriptorBufferOffsetsEXT( VkCommandBuffer      commandBuffer,
+                                               VkPipelineBindPoint  pipelineBindPoint,
+                                               VkPipelineLayout     layout,
+                                               uint32_t             firstSet,
+                                               uint32_t             setCount,
+                                               const uint32_t *     pBufferIndices,
+                                               const VkDeviceSize * pOffsets ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetDescriptorBufferOffsetsEXT( commandBuffer, pipelineBindPoint, layout, firstSet, setCount, pBufferIndices, pOffsets );
+      }
+
+      void vkCmdBindDescriptorBufferEmbeddedSamplersEXT( VkCommandBuffer     commandBuffer,
+                                                         VkPipelineBindPoint pipelineBindPoint,
+                                                         VkPipelineLayout    layout,
+                                                         uint32_t            set ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdBindDescriptorBufferEmbeddedSamplersEXT( commandBuffer, pipelineBindPoint, layout, set );
+      }
+
+      VkResult
+        vkGetBufferOpaqueCaptureDescriptorDataEXT( VkDevice device, const VkBufferCaptureDescriptorDataInfoEXT * pInfo, void * pData ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetBufferOpaqueCaptureDescriptorDataEXT( device, pInfo, pData );
+      }
+
+      VkResult
+        vkGetImageOpaqueCaptureDescriptorDataEXT( VkDevice device, const VkImageCaptureDescriptorDataInfoEXT * pInfo, void * pData ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetImageOpaqueCaptureDescriptorDataEXT( device, pInfo, pData );
+      }
+
+      VkResult vkGetImageViewOpaqueCaptureDescriptorDataEXT( VkDevice                                        device,
+                                                             const VkImageViewCaptureDescriptorDataInfoEXT * pInfo,
+                                                             void *                                          pData ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetImageViewOpaqueCaptureDescriptorDataEXT( device, pInfo, pData );
+      }
+
+      VkResult vkGetSamplerOpaqueCaptureDescriptorDataEXT( VkDevice                                      device,
+                                                           const VkSamplerCaptureDescriptorDataInfoEXT * pInfo,
+                                                           void *                                        pData ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetSamplerOpaqueCaptureDescriptorDataEXT( device, pInfo, pData );
+      }
+
+      VkResult vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT( VkDevice                                                    device,
+                                                                         const VkAccelerationStructureCaptureDescriptorDataInfoEXT * pInfo,
+                                                                         void * pData ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT( device, pInfo, pData );
+      }
+
+      //=== VK_NV_fragment_shading_rate_enums ===
+
+      void vkCmdSetFragmentShadingRateEnumNV( VkCommandBuffer                          commandBuffer,
+                                              VkFragmentShadingRateNV                  shadingRate,
+                                              const VkFragmentShadingRateCombinerOpKHR combinerOps[2] ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetFragmentShadingRateEnumNV( commandBuffer, shadingRate, combinerOps );
+      }
+
+      //=== VK_EXT_mesh_shader ===
+
+      void vkCmdDrawMeshTasksEXT( VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdDrawMeshTasksEXT( commandBuffer, groupCountX, groupCountY, groupCountZ );
+      }
+
+      void vkCmdDrawMeshTasksIndirectEXT( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride ) const
+        VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdDrawMeshTasksIndirectEXT( commandBuffer, buffer, offset, drawCount, stride );
+      }
+
+      void vkCmdDrawMeshTasksIndirectCountEXT( VkCommandBuffer commandBuffer,
+                                               VkBuffer        buffer,
+                                               VkDeviceSize    offset,
+                                               VkBuffer        countBuffer,
+                                               VkDeviceSize    countBufferOffset,
+                                               uint32_t        maxDrawCount,
+                                               uint32_t        stride ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdDrawMeshTasksIndirectCountEXT( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
+      }
+
+      //=== VK_KHR_copy_commands2 ===
+
+      void vkCmdCopyBuffer2KHR( VkCommandBuffer commandBuffer, const VkCopyBufferInfo2 * pCopyBufferInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdCopyBuffer2KHR( commandBuffer, pCopyBufferInfo );
+      }
+
+      void vkCmdCopyImage2KHR( VkCommandBuffer commandBuffer, const VkCopyImageInfo2 * pCopyImageInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdCopyImage2KHR( commandBuffer, pCopyImageInfo );
+      }
+
+      void vkCmdCopyBufferToImage2KHR( VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2 * pCopyBufferToImageInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdCopyBufferToImage2KHR( commandBuffer, pCopyBufferToImageInfo );
+      }
+
+      void vkCmdCopyImageToBuffer2KHR( VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2 * pCopyImageToBufferInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdCopyImageToBuffer2KHR( commandBuffer, pCopyImageToBufferInfo );
+      }
+
+      void vkCmdBlitImage2KHR( VkCommandBuffer commandBuffer, const VkBlitImageInfo2 * pBlitImageInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdBlitImage2KHR( commandBuffer, pBlitImageInfo );
+      }
+
+      void vkCmdResolveImage2KHR( VkCommandBuffer commandBuffer, const VkResolveImageInfo2 * pResolveImageInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdResolveImage2KHR( commandBuffer, pResolveImageInfo );
+      }
+
+      //=== VK_EXT_device_fault ===
+
+      VkResult vkGetDeviceFaultInfoEXT( VkDevice device, VkDeviceFaultCountsEXT * pFaultCounts, VkDeviceFaultInfoEXT * pFaultInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetDeviceFaultInfoEXT( device, pFaultCounts, pFaultInfo );
+      }
+
+#  if defined( VK_USE_PLATFORM_WIN32_KHR )
+      //=== VK_NV_acquire_winrt_display ===
+
+      VkResult vkAcquireWinrtDisplayNV( VkPhysicalDevice physicalDevice, VkDisplayKHR display ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkAcquireWinrtDisplayNV( physicalDevice, display );
+      }
+
+      VkResult vkGetWinrtDisplayNV( VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, VkDisplayKHR * pDisplay ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetWinrtDisplayNV( physicalDevice, deviceRelativeId, pDisplay );
+      }
 #  endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
 #  if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
-    //=== VK_EXT_directfb_surface ===
+      //=== VK_EXT_directfb_surface ===
 
-    VkResult vkCreateDirectFBSurfaceEXT( VkInstance                             instance,
-                                         const VkDirectFBSurfaceCreateInfoEXT * pCreateInfo,
-                                         const VkAllocationCallbacks *          pAllocator,
-                                         VkSurfaceKHR *                         pSurface ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateDirectFBSurfaceEXT( instance, pCreateInfo, pAllocator, pSurface );
-    }
+      VkResult vkCreateDirectFBSurfaceEXT( VkInstance                             instance,
+                                           const VkDirectFBSurfaceCreateInfoEXT * pCreateInfo,
+                                           const VkAllocationCallbacks *          pAllocator,
+                                           VkSurfaceKHR *                         pSurface ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateDirectFBSurfaceEXT( instance, pCreateInfo, pAllocator, pSurface );
+      }
 
-    VkBool32
-      vkGetPhysicalDeviceDirectFBPresentationSupportEXT( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, IDirectFB * dfb ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceDirectFBPresentationSupportEXT( physicalDevice, queueFamilyIndex, dfb );
-    }
+      VkBool32 vkGetPhysicalDeviceDirectFBPresentationSupportEXT( VkPhysicalDevice physicalDevice,
+                                                                  uint32_t         queueFamilyIndex,
+                                                                  IDirectFB *      dfb ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceDirectFBPresentationSupportEXT( physicalDevice, queueFamilyIndex, dfb );
+      }
 #  endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
 
-    //=== VK_EXT_vertex_input_dynamic_state ===
+      //=== VK_EXT_vertex_input_dynamic_state ===
 
-    void vkCmdSetVertexInputEXT( VkCommandBuffer                               commandBuffer,
-                                 uint32_t                                      vertexBindingDescriptionCount,
-                                 const VkVertexInputBindingDescription2EXT *   pVertexBindingDescriptions,
-                                 uint32_t                                      vertexAttributeDescriptionCount,
-                                 const VkVertexInputAttributeDescription2EXT * pVertexAttributeDescriptions ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetVertexInputEXT(
-        commandBuffer, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions );
-    }
+      void vkCmdSetVertexInputEXT( VkCommandBuffer                               commandBuffer,
+                                   uint32_t                                      vertexBindingDescriptionCount,
+                                   const VkVertexInputBindingDescription2EXT *   pVertexBindingDescriptions,
+                                   uint32_t                                      vertexAttributeDescriptionCount,
+                                   const VkVertexInputAttributeDescription2EXT * pVertexAttributeDescriptions ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetVertexInputEXT(
+          commandBuffer, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions );
+      }
 
 #  if defined( VK_USE_PLATFORM_FUCHSIA )
-    //=== VK_FUCHSIA_external_memory ===
+      //=== VK_FUCHSIA_external_memory ===
 
-    VkResult vkGetMemoryZirconHandleFUCHSIA( VkDevice                                   device,
-                                             const VkMemoryGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo,
-                                             zx_handle_t *                              pZirconHandle ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetMemoryZirconHandleFUCHSIA( device, pGetZirconHandleInfo, pZirconHandle );
-    }
+      VkResult vkGetMemoryZirconHandleFUCHSIA( VkDevice                                   device,
+                                               const VkMemoryGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo,
+                                               zx_handle_t *                              pZirconHandle ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetMemoryZirconHandleFUCHSIA( device, pGetZirconHandleInfo, pZirconHandle );
+      }
 
-    VkResult vkGetMemoryZirconHandlePropertiesFUCHSIA( VkDevice                                device,
-                                                       VkExternalMemoryHandleTypeFlagBits      handleType,
-                                                       zx_handle_t                             zirconHandle,
-                                                       VkMemoryZirconHandlePropertiesFUCHSIA * pMemoryZirconHandleProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetMemoryZirconHandlePropertiesFUCHSIA( device, handleType, zirconHandle, pMemoryZirconHandleProperties );
-    }
+      VkResult vkGetMemoryZirconHandlePropertiesFUCHSIA( VkDevice                                device,
+                                                         VkExternalMemoryHandleTypeFlagBits      handleType,
+                                                         zx_handle_t                             zirconHandle,
+                                                         VkMemoryZirconHandlePropertiesFUCHSIA * pMemoryZirconHandleProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetMemoryZirconHandlePropertiesFUCHSIA( device, handleType, zirconHandle, pMemoryZirconHandleProperties );
+      }
 #  endif /*VK_USE_PLATFORM_FUCHSIA*/
 
 #  if defined( VK_USE_PLATFORM_FUCHSIA )
-    //=== VK_FUCHSIA_external_semaphore ===
+      //=== VK_FUCHSIA_external_semaphore ===
 
-    VkResult vkImportSemaphoreZirconHandleFUCHSIA( VkDevice                                         device,
-                                                   const VkImportSemaphoreZirconHandleInfoFUCHSIA * pImportSemaphoreZirconHandleInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkImportSemaphoreZirconHandleFUCHSIA( device, pImportSemaphoreZirconHandleInfo );
-    }
+      VkResult
+        vkImportSemaphoreZirconHandleFUCHSIA( VkDevice                                         device,
+                                              const VkImportSemaphoreZirconHandleInfoFUCHSIA * pImportSemaphoreZirconHandleInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkImportSemaphoreZirconHandleFUCHSIA( device, pImportSemaphoreZirconHandleInfo );
+      }
 
-    VkResult vkGetSemaphoreZirconHandleFUCHSIA( VkDevice                                      device,
-                                                const VkSemaphoreGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo,
-                                                zx_handle_t *                                 pZirconHandle ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetSemaphoreZirconHandleFUCHSIA( device, pGetZirconHandleInfo, pZirconHandle );
-    }
+      VkResult vkGetSemaphoreZirconHandleFUCHSIA( VkDevice                                      device,
+                                                  const VkSemaphoreGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo,
+                                                  zx_handle_t *                                 pZirconHandle ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetSemaphoreZirconHandleFUCHSIA( device, pGetZirconHandleInfo, pZirconHandle );
+      }
 #  endif /*VK_USE_PLATFORM_FUCHSIA*/
 
 #  if defined( VK_USE_PLATFORM_FUCHSIA )
-    //=== VK_FUCHSIA_buffer_collection ===
+      //=== VK_FUCHSIA_buffer_collection ===
 
-    VkResult vkCreateBufferCollectionFUCHSIA( VkDevice                                    device,
-                                              const VkBufferCollectionCreateInfoFUCHSIA * pCreateInfo,
-                                              const VkAllocationCallbacks *               pAllocator,
-                                              VkBufferCollectionFUCHSIA *                 pCollection ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateBufferCollectionFUCHSIA( device, pCreateInfo, pAllocator, pCollection );
-    }
+      VkResult vkCreateBufferCollectionFUCHSIA( VkDevice                                    device,
+                                                const VkBufferCollectionCreateInfoFUCHSIA * pCreateInfo,
+                                                const VkAllocationCallbacks *               pAllocator,
+                                                VkBufferCollectionFUCHSIA *                 pCollection ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateBufferCollectionFUCHSIA( device, pCreateInfo, pAllocator, pCollection );
+      }
 
-    VkResult vkSetBufferCollectionImageConstraintsFUCHSIA( VkDevice                              device,
-                                                           VkBufferCollectionFUCHSIA             collection,
-                                                           const VkImageConstraintsInfoFUCHSIA * pImageConstraintsInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkSetBufferCollectionImageConstraintsFUCHSIA( device, collection, pImageConstraintsInfo );
-    }
+      VkResult vkSetBufferCollectionImageConstraintsFUCHSIA( VkDevice                              device,
+                                                             VkBufferCollectionFUCHSIA             collection,
+                                                             const VkImageConstraintsInfoFUCHSIA * pImageConstraintsInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkSetBufferCollectionImageConstraintsFUCHSIA( device, collection, pImageConstraintsInfo );
+      }
 
-    VkResult vkSetBufferCollectionBufferConstraintsFUCHSIA( VkDevice                               device,
-                                                            VkBufferCollectionFUCHSIA              collection,
-                                                            const VkBufferConstraintsInfoFUCHSIA * pBufferConstraintsInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkSetBufferCollectionBufferConstraintsFUCHSIA( device, collection, pBufferConstraintsInfo );
-    }
+      VkResult vkSetBufferCollectionBufferConstraintsFUCHSIA( VkDevice                               device,
+                                                              VkBufferCollectionFUCHSIA              collection,
+                                                              const VkBufferConstraintsInfoFUCHSIA * pBufferConstraintsInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkSetBufferCollectionBufferConstraintsFUCHSIA( device, collection, pBufferConstraintsInfo );
+      }
 
-    void vkDestroyBufferCollectionFUCHSIA( VkDevice                      device,
-                                           VkBufferCollectionFUCHSIA     collection,
-                                           const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkDestroyBufferCollectionFUCHSIA( device, collection, pAllocator );
-    }
-
-    VkResult vkGetBufferCollectionPropertiesFUCHSIA( VkDevice                              device,
-                                                     VkBufferCollectionFUCHSIA             collection,
-                                                     VkBufferCollectionPropertiesFUCHSIA * pProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetBufferCollectionPropertiesFUCHSIA( device, collection, pProperties );
-    }
-#  endif /*VK_USE_PLATFORM_FUCHSIA*/
-
-    //=== VK_HUAWEI_subpass_shading ===
-
-    VkResult
-      vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( VkDevice device, VkRenderPass renderpass, VkExtent2D * pMaxWorkgroupSize ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( device, renderpass, pMaxWorkgroupSize );
-    }
-
-    void vkCmdSubpassShadingHUAWEI( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSubpassShadingHUAWEI( commandBuffer );
-    }
-
-    //=== VK_HUAWEI_invocation_mask ===
-
-    void vkCmdBindInvocationMaskHUAWEI( VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdBindInvocationMaskHUAWEI( commandBuffer, imageView, imageLayout );
-    }
-
-    //=== VK_NV_external_memory_rdma ===
-
-    VkResult vkGetMemoryRemoteAddressNV( VkDevice                               device,
-                                         const VkMemoryGetRemoteAddressInfoNV * pMemoryGetRemoteAddressInfo,
-                                         VkRemoteAddressNV *                    pAddress ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetMemoryRemoteAddressNV( device, pMemoryGetRemoteAddressInfo, pAddress );
-    }
-
-    //=== VK_EXT_pipeline_properties ===
-
-    VkResult
-      vkGetPipelinePropertiesEXT( VkDevice device, const VkPipelineInfoEXT * pPipelineInfo, VkBaseOutStructure * pPipelineProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPipelinePropertiesEXT( device, pPipelineInfo, pPipelineProperties );
-    }
-
-    //=== VK_EXT_extended_dynamic_state2 ===
-
-    void vkCmdSetPatchControlPointsEXT( VkCommandBuffer commandBuffer, uint32_t patchControlPoints ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetPatchControlPointsEXT( commandBuffer, patchControlPoints );
-    }
-
-    void vkCmdSetRasterizerDiscardEnableEXT( VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetRasterizerDiscardEnableEXT( commandBuffer, rasterizerDiscardEnable );
-    }
-
-    void vkCmdSetDepthBiasEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetDepthBiasEnableEXT( commandBuffer, depthBiasEnable );
-    }
-
-    void vkCmdSetLogicOpEXT( VkCommandBuffer commandBuffer, VkLogicOp logicOp ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetLogicOpEXT( commandBuffer, logicOp );
-    }
-
-    void vkCmdSetPrimitiveRestartEnableEXT( VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetPrimitiveRestartEnableEXT( commandBuffer, primitiveRestartEnable );
-    }
-
-#  if defined( VK_USE_PLATFORM_SCREEN_QNX )
-    //=== VK_QNX_screen_surface ===
-
-    VkResult vkCreateScreenSurfaceQNX( VkInstance                           instance,
-                                       const VkScreenSurfaceCreateInfoQNX * pCreateInfo,
-                                       const VkAllocationCallbacks *        pAllocator,
-                                       VkSurfaceKHR *                       pSurface ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateScreenSurfaceQNX( instance, pCreateInfo, pAllocator, pSurface );
-    }
-
-    VkBool32 vkGetPhysicalDeviceScreenPresentationSupportQNX( VkPhysicalDevice        physicalDevice,
-                                                              uint32_t                queueFamilyIndex,
-                                                              struct _screen_window * window ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceScreenPresentationSupportQNX( physicalDevice, queueFamilyIndex, window );
-    }
-#  endif /*VK_USE_PLATFORM_SCREEN_QNX*/
-
-    //=== VK_EXT_color_write_enable ===
-
-    void vkCmdSetColorWriteEnableEXT( VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32 * pColorWriteEnables ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetColorWriteEnableEXT( commandBuffer, attachmentCount, pColorWriteEnables );
-    }
-
-    //=== VK_KHR_ray_tracing_maintenance1 ===
-
-    void vkCmdTraceRaysIndirect2KHR( VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdTraceRaysIndirect2KHR( commandBuffer, indirectDeviceAddress );
-    }
-
-    //=== VK_EXT_multi_draw ===
-
-    void vkCmdDrawMultiEXT( VkCommandBuffer            commandBuffer,
-                            uint32_t                   drawCount,
-                            const VkMultiDrawInfoEXT * pVertexInfo,
-                            uint32_t                   instanceCount,
-                            uint32_t                   firstInstance,
-                            uint32_t                   stride ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdDrawMultiEXT( commandBuffer, drawCount, pVertexInfo, instanceCount, firstInstance, stride );
-    }
-
-    void vkCmdDrawMultiIndexedEXT( VkCommandBuffer                   commandBuffer,
-                                   uint32_t                          drawCount,
-                                   const VkMultiDrawIndexedInfoEXT * pIndexInfo,
-                                   uint32_t                          instanceCount,
-                                   uint32_t                          firstInstance,
-                                   uint32_t                          stride,
-                                   const int32_t *                   pVertexOffset ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdDrawMultiIndexedEXT( commandBuffer, drawCount, pIndexInfo, instanceCount, firstInstance, stride, pVertexOffset );
-    }
-
-    //=== VK_EXT_opacity_micromap ===
-
-    VkResult vkCreateMicromapEXT( VkDevice                        device,
-                                  const VkMicromapCreateInfoEXT * pCreateInfo,
-                                  const VkAllocationCallbacks *   pAllocator,
-                                  VkMicromapEXT *                 pMicromap ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateMicromapEXT( device, pCreateInfo, pAllocator, pMicromap );
-    }
-
-    void vkDestroyMicromapEXT( VkDevice device, VkMicromapEXT micromap, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkDestroyMicromapEXT( device, micromap, pAllocator );
-    }
-
-    void vkCmdBuildMicromapsEXT( VkCommandBuffer commandBuffer, uint32_t infoCount, const VkMicromapBuildInfoEXT * pInfos ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdBuildMicromapsEXT( commandBuffer, infoCount, pInfos );
-    }
-
-    VkResult vkBuildMicromapsEXT( VkDevice                       device,
-                                  VkDeferredOperationKHR         deferredOperation,
-                                  uint32_t                       infoCount,
-                                  const VkMicromapBuildInfoEXT * pInfos ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkBuildMicromapsEXT( device, deferredOperation, infoCount, pInfos );
-    }
-
-    VkResult vkCopyMicromapEXT( VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapInfoEXT * pInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCopyMicromapEXT( device, deferredOperation, pInfo );
-    }
-
-    VkResult vkCopyMicromapToMemoryEXT( VkDevice                              device,
-                                        VkDeferredOperationKHR                deferredOperation,
-                                        const VkCopyMicromapToMemoryInfoEXT * pInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCopyMicromapToMemoryEXT( device, deferredOperation, pInfo );
-    }
-
-    VkResult vkCopyMemoryToMicromapEXT( VkDevice                              device,
-                                        VkDeferredOperationKHR                deferredOperation,
-                                        const VkCopyMemoryToMicromapInfoEXT * pInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCopyMemoryToMicromapEXT( device, deferredOperation, pInfo );
-    }
-
-    VkResult vkWriteMicromapsPropertiesEXT( VkDevice              device,
-                                            uint32_t              micromapCount,
-                                            const VkMicromapEXT * pMicromaps,
-                                            VkQueryType           queryType,
-                                            size_t                dataSize,
-                                            void *                pData,
-                                            size_t                stride ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkWriteMicromapsPropertiesEXT( device, micromapCount, pMicromaps, queryType, dataSize, pData, stride );
-    }
-
-    void vkCmdCopyMicromapEXT( VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT * pInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdCopyMicromapEXT( commandBuffer, pInfo );
-    }
-
-    void vkCmdCopyMicromapToMemoryEXT( VkCommandBuffer commandBuffer, const VkCopyMicromapToMemoryInfoEXT * pInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdCopyMicromapToMemoryEXT( commandBuffer, pInfo );
-    }
-
-    void vkCmdCopyMemoryToMicromapEXT( VkCommandBuffer commandBuffer, const VkCopyMemoryToMicromapInfoEXT * pInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdCopyMemoryToMicromapEXT( commandBuffer, pInfo );
-    }
-
-    void vkCmdWriteMicromapsPropertiesEXT( VkCommandBuffer       commandBuffer,
-                                           uint32_t              micromapCount,
-                                           const VkMicromapEXT * pMicromaps,
-                                           VkQueryType           queryType,
-                                           VkQueryPool           queryPool,
-                                           uint32_t              firstQuery ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdWriteMicromapsPropertiesEXT( commandBuffer, micromapCount, pMicromaps, queryType, queryPool, firstQuery );
-    }
-
-    void vkGetDeviceMicromapCompatibilityEXT( VkDevice                                  device,
-                                              const VkMicromapVersionInfoEXT *          pVersionInfo,
-                                              VkAccelerationStructureCompatibilityKHR * pCompatibility ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetDeviceMicromapCompatibilityEXT( device, pVersionInfo, pCompatibility );
-    }
-
-    void vkGetMicromapBuildSizesEXT( VkDevice                            device,
-                                     VkAccelerationStructureBuildTypeKHR buildType,
-                                     const VkMicromapBuildInfoEXT *      pBuildInfo,
-                                     VkMicromapBuildSizesInfoEXT *       pSizeInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetMicromapBuildSizesEXT( device, buildType, pBuildInfo, pSizeInfo );
-    }
-
-    //=== VK_HUAWEI_cluster_culling_shader ===
-
-    void vkCmdDrawClusterHUAWEI( VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdDrawClusterHUAWEI( commandBuffer, groupCountX, groupCountY, groupCountZ );
-    }
-
-    void vkCmdDrawClusterIndirectHUAWEI( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdDrawClusterIndirectHUAWEI( commandBuffer, buffer, offset );
-    }
-
-    //=== VK_EXT_pageable_device_local_memory ===
-
-    void vkSetDeviceMemoryPriorityEXT( VkDevice device, VkDeviceMemory memory, float priority ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkSetDeviceMemoryPriorityEXT( device, memory, priority );
-    }
-
-    //=== VK_KHR_maintenance4 ===
-
-    void vkGetDeviceBufferMemoryRequirementsKHR( VkDevice                                 device,
-                                                 const VkDeviceBufferMemoryRequirements * pInfo,
-                                                 VkMemoryRequirements2 *                  pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetDeviceBufferMemoryRequirementsKHR( device, pInfo, pMemoryRequirements );
-    }
-
-    void vkGetDeviceImageMemoryRequirementsKHR( VkDevice                                device,
-                                                const VkDeviceImageMemoryRequirements * pInfo,
-                                                VkMemoryRequirements2 *                 pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetDeviceImageMemoryRequirementsKHR( device, pInfo, pMemoryRequirements );
-    }
-
-    void vkGetDeviceImageSparseMemoryRequirementsKHR( VkDevice                                device,
-                                                      const VkDeviceImageMemoryRequirements * pInfo,
-                                                      uint32_t *                              pSparseMemoryRequirementCount,
-                                                      VkSparseImageMemoryRequirements2 *      pSparseMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetDeviceImageSparseMemoryRequirementsKHR( device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements );
-    }
-
-    //=== VK_VALVE_descriptor_set_host_mapping ===
-
-    void vkGetDescriptorSetLayoutHostMappingInfoVALVE( VkDevice                                     device,
-                                                       const VkDescriptorSetBindingReferenceVALVE * pBindingReference,
-                                                       VkDescriptorSetLayoutHostMappingInfoVALVE *  pHostMapping ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetDescriptorSetLayoutHostMappingInfoVALVE( device, pBindingReference, pHostMapping );
-    }
-
-    void vkGetDescriptorSetHostMappingVALVE( VkDevice device, VkDescriptorSet descriptorSet, void ** ppData ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetDescriptorSetHostMappingVALVE( device, descriptorSet, ppData );
-    }
-
-    //=== VK_NV_copy_memory_indirect ===
-
-    void vkCmdCopyMemoryIndirectNV( VkCommandBuffer commandBuffer,
-                                    VkDeviceAddress copyBufferAddress,
-                                    uint32_t        copyCount,
-                                    uint32_t        stride ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdCopyMemoryIndirectNV( commandBuffer, copyBufferAddress, copyCount, stride );
-    }
-
-    void vkCmdCopyMemoryToImageIndirectNV( VkCommandBuffer                  commandBuffer,
-                                           VkDeviceAddress                  copyBufferAddress,
-                                           uint32_t                         copyCount,
-                                           uint32_t                         stride,
-                                           VkImage                          dstImage,
-                                           VkImageLayout                    dstImageLayout,
-                                           const VkImageSubresourceLayers * pImageSubresources ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdCopyMemoryToImageIndirectNV( commandBuffer, copyBufferAddress, copyCount, stride, dstImage, dstImageLayout, pImageSubresources );
-    }
-
-    //=== VK_NV_memory_decompression ===
-
-    void vkCmdDecompressMemoryNV( VkCommandBuffer                    commandBuffer,
-                                  uint32_t                           decompressRegionCount,
-                                  const VkDecompressMemoryRegionNV * pDecompressMemoryRegions ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdDecompressMemoryNV( commandBuffer, decompressRegionCount, pDecompressMemoryRegions );
-    }
-
-    void vkCmdDecompressMemoryIndirectCountNV( VkCommandBuffer commandBuffer,
-                                               VkDeviceAddress indirectCommandsAddress,
-                                               VkDeviceAddress indirectCommandsCountAddress,
-                                               uint32_t        stride ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdDecompressMemoryIndirectCountNV( commandBuffer, indirectCommandsAddress, indirectCommandsCountAddress, stride );
-    }
-
-    //=== VK_NV_device_generated_commands_compute ===
-
-    void vkGetPipelineIndirectMemoryRequirementsNV( VkDevice                            device,
-                                                    const VkComputePipelineCreateInfo * pCreateInfo,
-                                                    VkMemoryRequirements2 *             pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPipelineIndirectMemoryRequirementsNV( device, pCreateInfo, pMemoryRequirements );
-    }
-
-    void
-      vkCmdUpdatePipelineIndirectBufferNV( VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdUpdatePipelineIndirectBufferNV( commandBuffer, pipelineBindPoint, pipeline );
-    }
-
-    VkDeviceAddress vkGetPipelineIndirectDeviceAddressNV( VkDevice device, const VkPipelineIndirectDeviceAddressInfoNV * pInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPipelineIndirectDeviceAddressNV( device, pInfo );
-    }
-
-    //=== VK_EXT_extended_dynamic_state3 ===
-
-    void vkCmdSetDepthClampEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthClampEnable ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetDepthClampEnableEXT( commandBuffer, depthClampEnable );
-    }
-
-    void vkCmdSetPolygonModeEXT( VkCommandBuffer commandBuffer, VkPolygonMode polygonMode ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetPolygonModeEXT( commandBuffer, polygonMode );
-    }
-
-    void vkCmdSetRasterizationSamplesEXT( VkCommandBuffer commandBuffer, VkSampleCountFlagBits rasterizationSamples ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetRasterizationSamplesEXT( commandBuffer, rasterizationSamples );
-    }
-
-    void vkCmdSetSampleMaskEXT( VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples, const VkSampleMask * pSampleMask ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetSampleMaskEXT( commandBuffer, samples, pSampleMask );
-    }
-
-    void vkCmdSetAlphaToCoverageEnableEXT( VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetAlphaToCoverageEnableEXT( commandBuffer, alphaToCoverageEnable );
-    }
-
-    void vkCmdSetAlphaToOneEnableEXT( VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetAlphaToOneEnableEXT( commandBuffer, alphaToOneEnable );
-    }
-
-    void vkCmdSetLogicOpEnableEXT( VkCommandBuffer commandBuffer, VkBool32 logicOpEnable ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetLogicOpEnableEXT( commandBuffer, logicOpEnable );
-    }
-
-    void vkCmdSetColorBlendEnableEXT( VkCommandBuffer  commandBuffer,
-                                      uint32_t         firstAttachment,
-                                      uint32_t         attachmentCount,
-                                      const VkBool32 * pColorBlendEnables ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetColorBlendEnableEXT( commandBuffer, firstAttachment, attachmentCount, pColorBlendEnables );
-    }
-
-    void vkCmdSetColorBlendEquationEXT( VkCommandBuffer                 commandBuffer,
-                                        uint32_t                        firstAttachment,
-                                        uint32_t                        attachmentCount,
-                                        const VkColorBlendEquationEXT * pColorBlendEquations ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetColorBlendEquationEXT( commandBuffer, firstAttachment, attachmentCount, pColorBlendEquations );
-    }
-
-    void vkCmdSetColorWriteMaskEXT( VkCommandBuffer               commandBuffer,
-                                    uint32_t                      firstAttachment,
-                                    uint32_t                      attachmentCount,
-                                    const VkColorComponentFlags * pColorWriteMasks ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetColorWriteMaskEXT( commandBuffer, firstAttachment, attachmentCount, pColorWriteMasks );
-    }
-
-    void vkCmdSetTessellationDomainOriginEXT( VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetTessellationDomainOriginEXT( commandBuffer, domainOrigin );
-    }
-
-    void vkCmdSetRasterizationStreamEXT( VkCommandBuffer commandBuffer, uint32_t rasterizationStream ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetRasterizationStreamEXT( commandBuffer, rasterizationStream );
-    }
-
-    void vkCmdSetConservativeRasterizationModeEXT( VkCommandBuffer                    commandBuffer,
-                                                   VkConservativeRasterizationModeEXT conservativeRasterizationMode ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetConservativeRasterizationModeEXT( commandBuffer, conservativeRasterizationMode );
-    }
-
-    void vkCmdSetExtraPrimitiveOverestimationSizeEXT( VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetExtraPrimitiveOverestimationSizeEXT( commandBuffer, extraPrimitiveOverestimationSize );
-    }
-
-    void vkCmdSetDepthClipEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthClipEnable ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetDepthClipEnableEXT( commandBuffer, depthClipEnable );
-    }
-
-    void vkCmdSetSampleLocationsEnableEXT( VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetSampleLocationsEnableEXT( commandBuffer, sampleLocationsEnable );
-    }
-
-    void vkCmdSetColorBlendAdvancedEXT( VkCommandBuffer                 commandBuffer,
-                                        uint32_t                        firstAttachment,
-                                        uint32_t                        attachmentCount,
-                                        const VkColorBlendAdvancedEXT * pColorBlendAdvanced ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetColorBlendAdvancedEXT( commandBuffer, firstAttachment, attachmentCount, pColorBlendAdvanced );
-    }
-
-    void vkCmdSetProvokingVertexModeEXT( VkCommandBuffer commandBuffer, VkProvokingVertexModeEXT provokingVertexMode ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetProvokingVertexModeEXT( commandBuffer, provokingVertexMode );
-    }
-
-    void vkCmdSetLineRasterizationModeEXT( VkCommandBuffer commandBuffer, VkLineRasterizationModeEXT lineRasterizationMode ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetLineRasterizationModeEXT( commandBuffer, lineRasterizationMode );
-    }
-
-    void vkCmdSetLineStippleEnableEXT( VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetLineStippleEnableEXT( commandBuffer, stippledLineEnable );
-    }
-
-    void vkCmdSetDepthClipNegativeOneToOneEXT( VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetDepthClipNegativeOneToOneEXT( commandBuffer, negativeOneToOne );
-    }
-
-    void vkCmdSetViewportWScalingEnableNV( VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetViewportWScalingEnableNV( commandBuffer, viewportWScalingEnable );
-    }
-
-    void vkCmdSetViewportSwizzleNV( VkCommandBuffer             commandBuffer,
-                                    uint32_t                    firstViewport,
-                                    uint32_t                    viewportCount,
-                                    const VkViewportSwizzleNV * pViewportSwizzles ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetViewportSwizzleNV( commandBuffer, firstViewport, viewportCount, pViewportSwizzles );
-    }
-
-    void vkCmdSetCoverageToColorEnableNV( VkCommandBuffer commandBuffer, VkBool32 coverageToColorEnable ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetCoverageToColorEnableNV( commandBuffer, coverageToColorEnable );
-    }
-
-    void vkCmdSetCoverageToColorLocationNV( VkCommandBuffer commandBuffer, uint32_t coverageToColorLocation ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetCoverageToColorLocationNV( commandBuffer, coverageToColorLocation );
-    }
-
-    void vkCmdSetCoverageModulationModeNV( VkCommandBuffer commandBuffer, VkCoverageModulationModeNV coverageModulationMode ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetCoverageModulationModeNV( commandBuffer, coverageModulationMode );
-    }
-
-    void vkCmdSetCoverageModulationTableEnableNV( VkCommandBuffer commandBuffer, VkBool32 coverageModulationTableEnable ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetCoverageModulationTableEnableNV( commandBuffer, coverageModulationTableEnable );
-    }
-
-    void vkCmdSetCoverageModulationTableNV( VkCommandBuffer commandBuffer,
-                                            uint32_t        coverageModulationTableCount,
-                                            const float *   pCoverageModulationTable ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetCoverageModulationTableNV( commandBuffer, coverageModulationTableCount, pCoverageModulationTable );
-    }
-
-    void vkCmdSetShadingRateImageEnableNV( VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetShadingRateImageEnableNV( commandBuffer, shadingRateImageEnable );
-    }
-
-    void vkCmdSetRepresentativeFragmentTestEnableNV( VkCommandBuffer commandBuffer, VkBool32 representativeFragmentTestEnable ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetRepresentativeFragmentTestEnableNV( commandBuffer, representativeFragmentTestEnable );
-    }
-
-    void vkCmdSetCoverageReductionModeNV( VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetCoverageReductionModeNV( commandBuffer, coverageReductionMode );
-    }
-
-    //=== VK_EXT_shader_module_identifier ===
-
-    void vkGetShaderModuleIdentifierEXT( VkDevice device, VkShaderModule shaderModule, VkShaderModuleIdentifierEXT * pIdentifier ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetShaderModuleIdentifierEXT( device, shaderModule, pIdentifier );
-    }
-
-    void vkGetShaderModuleCreateInfoIdentifierEXT( VkDevice                         device,
-                                                   const VkShaderModuleCreateInfo * pCreateInfo,
-                                                   VkShaderModuleIdentifierEXT *    pIdentifier ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetShaderModuleCreateInfoIdentifierEXT( device, pCreateInfo, pIdentifier );
-    }
-
-    //=== VK_NV_optical_flow ===
-
-    VkResult vkGetPhysicalDeviceOpticalFlowImageFormatsNV( VkPhysicalDevice                       physicalDevice,
-                                                           const VkOpticalFlowImageFormatInfoNV * pOpticalFlowImageFormatInfo,
-                                                           uint32_t *                             pFormatCount,
-                                                           VkOpticalFlowImageFormatPropertiesNV * pImageFormatProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceOpticalFlowImageFormatsNV( physicalDevice, pOpticalFlowImageFormatInfo, pFormatCount, pImageFormatProperties );
-    }
-
-    VkResult vkCreateOpticalFlowSessionNV( VkDevice                                 device,
-                                           const VkOpticalFlowSessionCreateInfoNV * pCreateInfo,
-                                           const VkAllocationCallbacks *            pAllocator,
-                                           VkOpticalFlowSessionNV *                 pSession ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateOpticalFlowSessionNV( device, pCreateInfo, pAllocator, pSession );
-    }
-
-    void vkDestroyOpticalFlowSessionNV( VkDevice device, VkOpticalFlowSessionNV session, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkDestroyOpticalFlowSessionNV( device, session, pAllocator );
-    }
-
-    VkResult vkBindOpticalFlowSessionImageNV( VkDevice                           device,
-                                              VkOpticalFlowSessionNV             session,
-                                              VkOpticalFlowSessionBindingPointNV bindingPoint,
-                                              VkImageView                        view,
-                                              VkImageLayout                      layout ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkBindOpticalFlowSessionImageNV( device, session, bindingPoint, view, layout );
-    }
-
-    void vkCmdOpticalFlowExecuteNV( VkCommandBuffer                    commandBuffer,
-                                    VkOpticalFlowSessionNV             session,
-                                    const VkOpticalFlowExecuteInfoNV * pExecuteInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdOpticalFlowExecuteNV( commandBuffer, session, pExecuteInfo );
-    }
-
-    //=== VK_KHR_maintenance5 ===
-
-    void vkCmdBindIndexBuffer2KHR( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType ) const
-      VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdBindIndexBuffer2KHR( commandBuffer, buffer, offset, size, indexType );
-    }
-
-    void vkGetRenderingAreaGranularityKHR( VkDevice                       device,
-                                           const VkRenderingAreaInfoKHR * pRenderingAreaInfo,
-                                           VkExtent2D *                   pGranularity ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetRenderingAreaGranularityKHR( device, pRenderingAreaInfo, pGranularity );
-    }
-
-    void vkGetDeviceImageSubresourceLayoutKHR( VkDevice                                device,
-                                               const VkDeviceImageSubresourceInfoKHR * pInfo,
-                                               VkSubresourceLayout2KHR *               pLayout ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetDeviceImageSubresourceLayoutKHR( device, pInfo, pLayout );
-    }
-
-    void vkGetImageSubresourceLayout2KHR( VkDevice                       device,
-                                          VkImage                        image,
-                                          const VkImageSubresource2KHR * pSubresource,
-                                          VkSubresourceLayout2KHR *      pLayout ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetImageSubresourceLayout2KHR( device, image, pSubresource, pLayout );
-    }
-
-    //=== VK_AMD_anti_lag ===
-
-    void vkAntiLagUpdateAMD( VkDevice device, const VkAntiLagDataAMD * pData ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkAntiLagUpdateAMD( device, pData );
-    }
-
-    //=== VK_EXT_shader_object ===
-
-    VkResult vkCreateShadersEXT( VkDevice                      device,
-                                 uint32_t                      createInfoCount,
-                                 const VkShaderCreateInfoEXT * pCreateInfos,
-                                 const VkAllocationCallbacks * pAllocator,
-                                 VkShaderEXT *                 pShaders ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateShadersEXT( device, createInfoCount, pCreateInfos, pAllocator, pShaders );
-    }
-
-    void vkDestroyShaderEXT( VkDevice device, VkShaderEXT shader, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkDestroyShaderEXT( device, shader, pAllocator );
-    }
-
-    VkResult vkGetShaderBinaryDataEXT( VkDevice device, VkShaderEXT shader, size_t * pDataSize, void * pData ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetShaderBinaryDataEXT( device, shader, pDataSize, pData );
-    }
-
-    void vkCmdBindShadersEXT( VkCommandBuffer               commandBuffer,
-                              uint32_t                      stageCount,
-                              const VkShaderStageFlagBits * pStages,
-                              const VkShaderEXT *           pShaders ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdBindShadersEXT( commandBuffer, stageCount, pStages, pShaders );
-    }
-
-    void vkCmdSetDepthClampRangeEXT( VkCommandBuffer              commandBuffer,
-                                     VkDepthClampModeEXT          depthClampMode,
-                                     const VkDepthClampRangeEXT * pDepthClampRange ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetDepthClampRangeEXT( commandBuffer, depthClampMode, pDepthClampRange );
-    }
-
-    //=== VK_KHR_pipeline_binary ===
-
-    VkResult vkCreatePipelineBinariesKHR( VkDevice                              device,
-                                          const VkPipelineBinaryCreateInfoKHR * pCreateInfo,
-                                          const VkAllocationCallbacks *         pAllocator,
-                                          VkPipelineBinaryHandlesInfoKHR *      pBinaries ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreatePipelineBinariesKHR( device, pCreateInfo, pAllocator, pBinaries );
-    }
-
-    void vkDestroyPipelineBinaryKHR( VkDevice device, VkPipelineBinaryKHR pipelineBinary, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkDestroyPipelineBinaryKHR( device, pipelineBinary, pAllocator );
-    }
-
-    VkResult vkGetPipelineKeyKHR( VkDevice                        device,
-                                  const VkPipelineCreateInfoKHR * pPipelineCreateInfo,
-                                  VkPipelineBinaryKeyKHR *        pPipelineKey ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPipelineKeyKHR( device, pPipelineCreateInfo, pPipelineKey );
-    }
-
-    VkResult vkGetPipelineBinaryDataKHR( VkDevice                            device,
-                                         const VkPipelineBinaryDataInfoKHR * pInfo,
-                                         VkPipelineBinaryKeyKHR *            pPipelineBinaryKey,
-                                         size_t *                            pPipelineBinaryDataSize,
-                                         void *                              pPipelineBinaryData ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPipelineBinaryDataKHR( device, pInfo, pPipelineBinaryKey, pPipelineBinaryDataSize, pPipelineBinaryData );
-    }
-
-    VkResult vkReleaseCapturedPipelineDataKHR( VkDevice                                     device,
-                                               const VkReleaseCapturedPipelineDataInfoKHR * pInfo,
-                                               const VkAllocationCallbacks *                pAllocator ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkReleaseCapturedPipelineDataKHR( device, pInfo, pAllocator );
-    }
-
-    //=== VK_QCOM_tile_properties ===
-
-    VkResult vkGetFramebufferTilePropertiesQCOM( VkDevice               device,
-                                                 VkFramebuffer          framebuffer,
-                                                 uint32_t *             pPropertiesCount,
-                                                 VkTilePropertiesQCOM * pProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetFramebufferTilePropertiesQCOM( device, framebuffer, pPropertiesCount, pProperties );
-    }
-
-    VkResult vkGetDynamicRenderingTilePropertiesQCOM( VkDevice                device,
-                                                      const VkRenderingInfo * pRenderingInfo,
-                                                      VkTilePropertiesQCOM *  pProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetDynamicRenderingTilePropertiesQCOM( device, pRenderingInfo, pProperties );
-    }
-
-    //=== VK_NV_low_latency2 ===
-
-    VkResult vkSetLatencySleepModeNV( VkDevice device, VkSwapchainKHR swapchain, const VkLatencySleepModeInfoNV * pSleepModeInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkSetLatencySleepModeNV( device, swapchain, pSleepModeInfo );
-    }
-
-    VkResult vkLatencySleepNV( VkDevice device, VkSwapchainKHR swapchain, const VkLatencySleepInfoNV * pSleepInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkLatencySleepNV( device, swapchain, pSleepInfo );
-    }
-
-    void vkSetLatencyMarkerNV( VkDevice device, VkSwapchainKHR swapchain, const VkSetLatencyMarkerInfoNV * pLatencyMarkerInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkSetLatencyMarkerNV( device, swapchain, pLatencyMarkerInfo );
-    }
-
-    void vkGetLatencyTimingsNV( VkDevice device, VkSwapchainKHR swapchain, VkGetLatencyMarkerInfoNV * pLatencyMarkerInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetLatencyTimingsNV( device, swapchain, pLatencyMarkerInfo );
-    }
-
-    void vkQueueNotifyOutOfBandNV( VkQueue queue, const VkOutOfBandQueueTypeInfoNV * pQueueTypeInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkQueueNotifyOutOfBandNV( queue, pQueueTypeInfo );
-    }
-
-    //=== VK_KHR_cooperative_matrix ===
-
-    VkResult vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR( VkPhysicalDevice                   physicalDevice,
-                                                                uint32_t *                         pPropertyCount,
-                                                                VkCooperativeMatrixPropertiesKHR * pProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR( physicalDevice, pPropertyCount, pProperties );
-    }
-
-    //=== VK_EXT_attachment_feedback_loop_dynamic_state ===
-
-    void vkCmdSetAttachmentFeedbackLoopEnableEXT( VkCommandBuffer commandBuffer, VkImageAspectFlags aspectMask ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetAttachmentFeedbackLoopEnableEXT( commandBuffer, aspectMask );
-    }
-
-#  if defined( VK_USE_PLATFORM_SCREEN_QNX )
-    //=== VK_QNX_external_memory_screen_buffer ===
-
-    VkResult vkGetScreenBufferPropertiesQNX( VkDevice                      device,
-                                             const struct _screen_buffer * buffer,
-                                             VkScreenBufferPropertiesQNX * pProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetScreenBufferPropertiesQNX( device, buffer, pProperties );
-    }
-#  endif /*VK_USE_PLATFORM_SCREEN_QNX*/
-
-    //=== VK_KHR_line_rasterization ===
-
-    void vkCmdSetLineStippleKHR( VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetLineStippleKHR( commandBuffer, lineStippleFactor, lineStipplePattern );
-    }
-
-    //=== VK_KHR_calibrated_timestamps ===
-
-    VkResult vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( VkPhysicalDevice  physicalDevice,
-                                                             uint32_t *        pTimeDomainCount,
-                                                             VkTimeDomainKHR * pTimeDomains ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( physicalDevice, pTimeDomainCount, pTimeDomains );
-    }
-
-    VkResult vkGetCalibratedTimestampsKHR( VkDevice                             device,
-                                           uint32_t                             timestampCount,
-                                           const VkCalibratedTimestampInfoKHR * pTimestampInfos,
-                                           uint64_t *                           pTimestamps,
-                                           uint64_t *                           pMaxDeviation ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetCalibratedTimestampsKHR( device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation );
-    }
-
-    //=== VK_KHR_maintenance6 ===
-
-    void vkCmdBindDescriptorSets2KHR( VkCommandBuffer commandBuffer, const VkBindDescriptorSetsInfoKHR * pBindDescriptorSetsInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdBindDescriptorSets2KHR( commandBuffer, pBindDescriptorSetsInfo );
-    }
-
-    void vkCmdPushConstants2KHR( VkCommandBuffer commandBuffer, const VkPushConstantsInfoKHR * pPushConstantsInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdPushConstants2KHR( commandBuffer, pPushConstantsInfo );
-    }
-
-    void vkCmdPushDescriptorSet2KHR( VkCommandBuffer commandBuffer, const VkPushDescriptorSetInfoKHR * pPushDescriptorSetInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdPushDescriptorSet2KHR( commandBuffer, pPushDescriptorSetInfo );
-    }
-
-    void vkCmdPushDescriptorSetWithTemplate2KHR( VkCommandBuffer                                commandBuffer,
-                                                 const VkPushDescriptorSetWithTemplateInfoKHR * pPushDescriptorSetWithTemplateInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdPushDescriptorSetWithTemplate2KHR( commandBuffer, pPushDescriptorSetWithTemplateInfo );
-    }
-
-    void vkCmdSetDescriptorBufferOffsets2EXT( VkCommandBuffer                             commandBuffer,
-                                              const VkSetDescriptorBufferOffsetsInfoEXT * pSetDescriptorBufferOffsetsInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdSetDescriptorBufferOffsets2EXT( commandBuffer, pSetDescriptorBufferOffsetsInfo );
-    }
-
-    void vkCmdBindDescriptorBufferEmbeddedSamplers2EXT(
-      VkCommandBuffer commandBuffer, const VkBindDescriptorBufferEmbeddedSamplersInfoEXT * pBindDescriptorBufferEmbeddedSamplersInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdBindDescriptorBufferEmbeddedSamplers2EXT( commandBuffer, pBindDescriptorBufferEmbeddedSamplersInfo );
-    }
-
-    //=== VK_EXT_device_generated_commands ===
-
-    void vkGetGeneratedCommandsMemoryRequirementsEXT( VkDevice                                             device,
-                                                      const VkGeneratedCommandsMemoryRequirementsInfoEXT * pInfo,
-                                                      VkMemoryRequirements2 *                              pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetGeneratedCommandsMemoryRequirementsEXT( device, pInfo, pMemoryRequirements );
-    }
-
-    void vkCmdPreprocessGeneratedCommandsEXT( VkCommandBuffer                    commandBuffer,
-                                              const VkGeneratedCommandsInfoEXT * pGeneratedCommandsInfo,
-                                              VkCommandBuffer                    stateCommandBuffer ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdPreprocessGeneratedCommandsEXT( commandBuffer, pGeneratedCommandsInfo, stateCommandBuffer );
-    }
-
-    void vkCmdExecuteGeneratedCommandsEXT( VkCommandBuffer                    commandBuffer,
-                                           VkBool32                           isPreprocessed,
-                                           const VkGeneratedCommandsInfoEXT * pGeneratedCommandsInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCmdExecuteGeneratedCommandsEXT( commandBuffer, isPreprocessed, pGeneratedCommandsInfo );
-    }
-
-    VkResult vkCreateIndirectCommandsLayoutEXT( VkDevice                                      device,
-                                                const VkIndirectCommandsLayoutCreateInfoEXT * pCreateInfo,
-                                                const VkAllocationCallbacks *                 pAllocator,
-                                                VkIndirectCommandsLayoutEXT *                 pIndirectCommandsLayout ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateIndirectCommandsLayoutEXT( device, pCreateInfo, pAllocator, pIndirectCommandsLayout );
-    }
-
-    void vkDestroyIndirectCommandsLayoutEXT( VkDevice                      device,
-                                             VkIndirectCommandsLayoutEXT   indirectCommandsLayout,
+      void vkDestroyBufferCollectionFUCHSIA( VkDevice                      device,
+                                             VkBufferCollectionFUCHSIA     collection,
                                              const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkDestroyBufferCollectionFUCHSIA( device, collection, pAllocator );
+      }
+
+      VkResult vkGetBufferCollectionPropertiesFUCHSIA( VkDevice                              device,
+                                                       VkBufferCollectionFUCHSIA             collection,
+                                                       VkBufferCollectionPropertiesFUCHSIA * pProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetBufferCollectionPropertiesFUCHSIA( device, collection, pProperties );
+      }
+#  endif /*VK_USE_PLATFORM_FUCHSIA*/
+
+      //=== VK_HUAWEI_subpass_shading ===
+
+      VkResult
+        vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( VkDevice device, VkRenderPass renderpass, VkExtent2D * pMaxWorkgroupSize ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( device, renderpass, pMaxWorkgroupSize );
+      }
+
+      void vkCmdSubpassShadingHUAWEI( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSubpassShadingHUAWEI( commandBuffer );
+      }
+
+      //=== VK_HUAWEI_invocation_mask ===
+
+      void vkCmdBindInvocationMaskHUAWEI( VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdBindInvocationMaskHUAWEI( commandBuffer, imageView, imageLayout );
+      }
+
+      //=== VK_NV_external_memory_rdma ===
+
+      VkResult vkGetMemoryRemoteAddressNV( VkDevice                               device,
+                                           const VkMemoryGetRemoteAddressInfoNV * pMemoryGetRemoteAddressInfo,
+                                           VkRemoteAddressNV *                    pAddress ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetMemoryRemoteAddressNV( device, pMemoryGetRemoteAddressInfo, pAddress );
+      }
+
+      //=== VK_EXT_pipeline_properties ===
+
+      VkResult vkGetPipelinePropertiesEXT( VkDevice                  device,
+                                           const VkPipelineInfoEXT * pPipelineInfo,
+                                           VkBaseOutStructure *      pPipelineProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPipelinePropertiesEXT( device, pPipelineInfo, pPipelineProperties );
+      }
+
+      //=== VK_EXT_extended_dynamic_state2 ===
+
+      void vkCmdSetPatchControlPointsEXT( VkCommandBuffer commandBuffer, uint32_t patchControlPoints ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetPatchControlPointsEXT( commandBuffer, patchControlPoints );
+      }
+
+      void vkCmdSetRasterizerDiscardEnableEXT( VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetRasterizerDiscardEnableEXT( commandBuffer, rasterizerDiscardEnable );
+      }
+
+      void vkCmdSetDepthBiasEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetDepthBiasEnableEXT( commandBuffer, depthBiasEnable );
+      }
+
+      void vkCmdSetLogicOpEXT( VkCommandBuffer commandBuffer, VkLogicOp logicOp ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetLogicOpEXT( commandBuffer, logicOp );
+      }
+
+      void vkCmdSetPrimitiveRestartEnableEXT( VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetPrimitiveRestartEnableEXT( commandBuffer, primitiveRestartEnable );
+      }
+
+#  if defined( VK_USE_PLATFORM_SCREEN_QNX )
+      //=== VK_QNX_screen_surface ===
+
+      VkResult vkCreateScreenSurfaceQNX( VkInstance                           instance,
+                                         const VkScreenSurfaceCreateInfoQNX * pCreateInfo,
+                                         const VkAllocationCallbacks *        pAllocator,
+                                         VkSurfaceKHR *                       pSurface ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateScreenSurfaceQNX( instance, pCreateInfo, pAllocator, pSurface );
+      }
+
+      VkBool32 vkGetPhysicalDeviceScreenPresentationSupportQNX( VkPhysicalDevice        physicalDevice,
+                                                                uint32_t                queueFamilyIndex,
+                                                                struct _screen_window * window ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceScreenPresentationSupportQNX( physicalDevice, queueFamilyIndex, window );
+      }
+#  endif /*VK_USE_PLATFORM_SCREEN_QNX*/
+
+      //=== VK_EXT_color_write_enable ===
+
+      void vkCmdSetColorWriteEnableEXT( VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32 * pColorWriteEnables ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetColorWriteEnableEXT( commandBuffer, attachmentCount, pColorWriteEnables );
+      }
+
+      //=== VK_KHR_ray_tracing_maintenance1 ===
+
+      void vkCmdTraceRaysIndirect2KHR( VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdTraceRaysIndirect2KHR( commandBuffer, indirectDeviceAddress );
+      }
+
+      //=== VK_EXT_multi_draw ===
+
+      void vkCmdDrawMultiEXT( VkCommandBuffer            commandBuffer,
+                              uint32_t                   drawCount,
+                              const VkMultiDrawInfoEXT * pVertexInfo,
+                              uint32_t                   instanceCount,
+                              uint32_t                   firstInstance,
+                              uint32_t                   stride ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdDrawMultiEXT( commandBuffer, drawCount, pVertexInfo, instanceCount, firstInstance, stride );
+      }
+
+      void vkCmdDrawMultiIndexedEXT( VkCommandBuffer                   commandBuffer,
+                                     uint32_t                          drawCount,
+                                     const VkMultiDrawIndexedInfoEXT * pIndexInfo,
+                                     uint32_t                          instanceCount,
+                                     uint32_t                          firstInstance,
+                                     uint32_t                          stride,
+                                     const int32_t *                   pVertexOffset ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdDrawMultiIndexedEXT( commandBuffer, drawCount, pIndexInfo, instanceCount, firstInstance, stride, pVertexOffset );
+      }
+
+      //=== VK_EXT_opacity_micromap ===
+
+      VkResult vkCreateMicromapEXT( VkDevice                        device,
+                                    const VkMicromapCreateInfoEXT * pCreateInfo,
+                                    const VkAllocationCallbacks *   pAllocator,
+                                    VkMicromapEXT *                 pMicromap ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateMicromapEXT( device, pCreateInfo, pAllocator, pMicromap );
+      }
+
+      void vkDestroyMicromapEXT( VkDevice device, VkMicromapEXT micromap, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkDestroyMicromapEXT( device, micromap, pAllocator );
+      }
+
+      void vkCmdBuildMicromapsEXT( VkCommandBuffer commandBuffer, uint32_t infoCount, const VkMicromapBuildInfoEXT * pInfos ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdBuildMicromapsEXT( commandBuffer, infoCount, pInfos );
+      }
+
+      VkResult vkBuildMicromapsEXT( VkDevice                       device,
+                                    VkDeferredOperationKHR         deferredOperation,
+                                    uint32_t                       infoCount,
+                                    const VkMicromapBuildInfoEXT * pInfos ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkBuildMicromapsEXT( device, deferredOperation, infoCount, pInfos );
+      }
+
+      VkResult vkCopyMicromapEXT( VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapInfoEXT * pInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCopyMicromapEXT( device, deferredOperation, pInfo );
+      }
+
+      VkResult vkCopyMicromapToMemoryEXT( VkDevice                              device,
+                                          VkDeferredOperationKHR                deferredOperation,
+                                          const VkCopyMicromapToMemoryInfoEXT * pInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCopyMicromapToMemoryEXT( device, deferredOperation, pInfo );
+      }
+
+      VkResult vkCopyMemoryToMicromapEXT( VkDevice                              device,
+                                          VkDeferredOperationKHR                deferredOperation,
+                                          const VkCopyMemoryToMicromapInfoEXT * pInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCopyMemoryToMicromapEXT( device, deferredOperation, pInfo );
+      }
+
+      VkResult vkWriteMicromapsPropertiesEXT( VkDevice              device,
+                                              uint32_t              micromapCount,
+                                              const VkMicromapEXT * pMicromaps,
+                                              VkQueryType           queryType,
+                                              size_t                dataSize,
+                                              void *                pData,
+                                              size_t                stride ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkWriteMicromapsPropertiesEXT( device, micromapCount, pMicromaps, queryType, dataSize, pData, stride );
+      }
+
+      void vkCmdCopyMicromapEXT( VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT * pInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdCopyMicromapEXT( commandBuffer, pInfo );
+      }
+
+      void vkCmdCopyMicromapToMemoryEXT( VkCommandBuffer commandBuffer, const VkCopyMicromapToMemoryInfoEXT * pInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdCopyMicromapToMemoryEXT( commandBuffer, pInfo );
+      }
+
+      void vkCmdCopyMemoryToMicromapEXT( VkCommandBuffer commandBuffer, const VkCopyMemoryToMicromapInfoEXT * pInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdCopyMemoryToMicromapEXT( commandBuffer, pInfo );
+      }
+
+      void vkCmdWriteMicromapsPropertiesEXT( VkCommandBuffer       commandBuffer,
+                                             uint32_t              micromapCount,
+                                             const VkMicromapEXT * pMicromaps,
+                                             VkQueryType           queryType,
+                                             VkQueryPool           queryPool,
+                                             uint32_t              firstQuery ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdWriteMicromapsPropertiesEXT( commandBuffer, micromapCount, pMicromaps, queryType, queryPool, firstQuery );
+      }
+
+      void vkGetDeviceMicromapCompatibilityEXT( VkDevice                                  device,
+                                                const VkMicromapVersionInfoEXT *          pVersionInfo,
+                                                VkAccelerationStructureCompatibilityKHR * pCompatibility ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetDeviceMicromapCompatibilityEXT( device, pVersionInfo, pCompatibility );
+      }
+
+      void vkGetMicromapBuildSizesEXT( VkDevice                            device,
+                                       VkAccelerationStructureBuildTypeKHR buildType,
+                                       const VkMicromapBuildInfoEXT *      pBuildInfo,
+                                       VkMicromapBuildSizesInfoEXT *       pSizeInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetMicromapBuildSizesEXT( device, buildType, pBuildInfo, pSizeInfo );
+      }
+
+      //=== VK_HUAWEI_cluster_culling_shader ===
+
+      void vkCmdDrawClusterHUAWEI( VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdDrawClusterHUAWEI( commandBuffer, groupCountX, groupCountY, groupCountZ );
+      }
+
+      void vkCmdDrawClusterIndirectHUAWEI( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdDrawClusterIndirectHUAWEI( commandBuffer, buffer, offset );
+      }
+
+      //=== VK_EXT_pageable_device_local_memory ===
+
+      void vkSetDeviceMemoryPriorityEXT( VkDevice device, VkDeviceMemory memory, float priority ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkSetDeviceMemoryPriorityEXT( device, memory, priority );
+      }
+
+      //=== VK_KHR_maintenance4 ===
+
+      void vkGetDeviceBufferMemoryRequirementsKHR( VkDevice                                 device,
+                                                   const VkDeviceBufferMemoryRequirements * pInfo,
+                                                   VkMemoryRequirements2 *                  pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetDeviceBufferMemoryRequirementsKHR( device, pInfo, pMemoryRequirements );
+      }
+
+      void vkGetDeviceImageMemoryRequirementsKHR( VkDevice                                device,
+                                                  const VkDeviceImageMemoryRequirements * pInfo,
+                                                  VkMemoryRequirements2 *                 pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetDeviceImageMemoryRequirementsKHR( device, pInfo, pMemoryRequirements );
+      }
+
+      void vkGetDeviceImageSparseMemoryRequirementsKHR( VkDevice                                device,
+                                                        const VkDeviceImageMemoryRequirements * pInfo,
+                                                        uint32_t *                              pSparseMemoryRequirementCount,
+                                                        VkSparseImageMemoryRequirements2 *      pSparseMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetDeviceImageSparseMemoryRequirementsKHR( device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements );
+      }
+
+      //=== VK_VALVE_descriptor_set_host_mapping ===
+
+      void vkGetDescriptorSetLayoutHostMappingInfoVALVE( VkDevice                                     device,
+                                                         const VkDescriptorSetBindingReferenceVALVE * pBindingReference,
+                                                         VkDescriptorSetLayoutHostMappingInfoVALVE *  pHostMapping ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetDescriptorSetLayoutHostMappingInfoVALVE( device, pBindingReference, pHostMapping );
+      }
+
+      void vkGetDescriptorSetHostMappingVALVE( VkDevice device, VkDescriptorSet descriptorSet, void ** ppData ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetDescriptorSetHostMappingVALVE( device, descriptorSet, ppData );
+      }
+
+      //=== VK_NV_copy_memory_indirect ===
+
+      void vkCmdCopyMemoryIndirectNV( VkCommandBuffer commandBuffer,
+                                      VkDeviceAddress copyBufferAddress,
+                                      uint32_t        copyCount,
+                                      uint32_t        stride ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdCopyMemoryIndirectNV( commandBuffer, copyBufferAddress, copyCount, stride );
+      }
+
+      void vkCmdCopyMemoryToImageIndirectNV( VkCommandBuffer                  commandBuffer,
+                                             VkDeviceAddress                  copyBufferAddress,
+                                             uint32_t                         copyCount,
+                                             uint32_t                         stride,
+                                             VkImage                          dstImage,
+                                             VkImageLayout                    dstImageLayout,
+                                             const VkImageSubresourceLayers * pImageSubresources ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdCopyMemoryToImageIndirectNV( commandBuffer, copyBufferAddress, copyCount, stride, dstImage, dstImageLayout, pImageSubresources );
+      }
+
+      //=== VK_NV_memory_decompression ===
+
+      void vkCmdDecompressMemoryNV( VkCommandBuffer                    commandBuffer,
+                                    uint32_t                           decompressRegionCount,
+                                    const VkDecompressMemoryRegionNV * pDecompressMemoryRegions ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdDecompressMemoryNV( commandBuffer, decompressRegionCount, pDecompressMemoryRegions );
+      }
+
+      void vkCmdDecompressMemoryIndirectCountNV( VkCommandBuffer commandBuffer,
+                                                 VkDeviceAddress indirectCommandsAddress,
+                                                 VkDeviceAddress indirectCommandsCountAddress,
+                                                 uint32_t        stride ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdDecompressMemoryIndirectCountNV( commandBuffer, indirectCommandsAddress, indirectCommandsCountAddress, stride );
+      }
+
+      //=== VK_NV_device_generated_commands_compute ===
+
+      void vkGetPipelineIndirectMemoryRequirementsNV( VkDevice                            device,
+                                                      const VkComputePipelineCreateInfo * pCreateInfo,
+                                                      VkMemoryRequirements2 *             pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPipelineIndirectMemoryRequirementsNV( device, pCreateInfo, pMemoryRequirements );
+      }
+
+      void vkCmdUpdatePipelineIndirectBufferNV( VkCommandBuffer     commandBuffer,
+                                                VkPipelineBindPoint pipelineBindPoint,
+                                                VkPipeline          pipeline ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdUpdatePipelineIndirectBufferNV( commandBuffer, pipelineBindPoint, pipeline );
+      }
+
+      VkDeviceAddress vkGetPipelineIndirectDeviceAddressNV( VkDevice device, const VkPipelineIndirectDeviceAddressInfoNV * pInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPipelineIndirectDeviceAddressNV( device, pInfo );
+      }
+
+      //=== VK_EXT_extended_dynamic_state3 ===
+
+      void vkCmdSetDepthClampEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthClampEnable ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetDepthClampEnableEXT( commandBuffer, depthClampEnable );
+      }
+
+      void vkCmdSetPolygonModeEXT( VkCommandBuffer commandBuffer, VkPolygonMode polygonMode ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetPolygonModeEXT( commandBuffer, polygonMode );
+      }
+
+      void vkCmdSetRasterizationSamplesEXT( VkCommandBuffer commandBuffer, VkSampleCountFlagBits rasterizationSamples ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetRasterizationSamplesEXT( commandBuffer, rasterizationSamples );
+      }
+
+      void vkCmdSetSampleMaskEXT( VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples, const VkSampleMask * pSampleMask ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetSampleMaskEXT( commandBuffer, samples, pSampleMask );
+      }
+
+      void vkCmdSetAlphaToCoverageEnableEXT( VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetAlphaToCoverageEnableEXT( commandBuffer, alphaToCoverageEnable );
+      }
+
+      void vkCmdSetAlphaToOneEnableEXT( VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetAlphaToOneEnableEXT( commandBuffer, alphaToOneEnable );
+      }
+
+      void vkCmdSetLogicOpEnableEXT( VkCommandBuffer commandBuffer, VkBool32 logicOpEnable ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetLogicOpEnableEXT( commandBuffer, logicOpEnable );
+      }
+
+      void vkCmdSetColorBlendEnableEXT( VkCommandBuffer  commandBuffer,
+                                        uint32_t         firstAttachment,
+                                        uint32_t         attachmentCount,
+                                        const VkBool32 * pColorBlendEnables ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetColorBlendEnableEXT( commandBuffer, firstAttachment, attachmentCount, pColorBlendEnables );
+      }
+
+      void vkCmdSetColorBlendEquationEXT( VkCommandBuffer                 commandBuffer,
+                                          uint32_t                        firstAttachment,
+                                          uint32_t                        attachmentCount,
+                                          const VkColorBlendEquationEXT * pColorBlendEquations ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetColorBlendEquationEXT( commandBuffer, firstAttachment, attachmentCount, pColorBlendEquations );
+      }
+
+      void vkCmdSetColorWriteMaskEXT( VkCommandBuffer               commandBuffer,
+                                      uint32_t                      firstAttachment,
+                                      uint32_t                      attachmentCount,
+                                      const VkColorComponentFlags * pColorWriteMasks ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetColorWriteMaskEXT( commandBuffer, firstAttachment, attachmentCount, pColorWriteMasks );
+      }
+
+      void vkCmdSetTessellationDomainOriginEXT( VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetTessellationDomainOriginEXT( commandBuffer, domainOrigin );
+      }
+
+      void vkCmdSetRasterizationStreamEXT( VkCommandBuffer commandBuffer, uint32_t rasterizationStream ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetRasterizationStreamEXT( commandBuffer, rasterizationStream );
+      }
+
+      void vkCmdSetConservativeRasterizationModeEXT( VkCommandBuffer                    commandBuffer,
+                                                     VkConservativeRasterizationModeEXT conservativeRasterizationMode ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetConservativeRasterizationModeEXT( commandBuffer, conservativeRasterizationMode );
+      }
+
+      void vkCmdSetExtraPrimitiveOverestimationSizeEXT( VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetExtraPrimitiveOverestimationSizeEXT( commandBuffer, extraPrimitiveOverestimationSize );
+      }
+
+      void vkCmdSetDepthClipEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthClipEnable ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetDepthClipEnableEXT( commandBuffer, depthClipEnable );
+      }
+
+      void vkCmdSetSampleLocationsEnableEXT( VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetSampleLocationsEnableEXT( commandBuffer, sampleLocationsEnable );
+      }
+
+      void vkCmdSetColorBlendAdvancedEXT( VkCommandBuffer                 commandBuffer,
+                                          uint32_t                        firstAttachment,
+                                          uint32_t                        attachmentCount,
+                                          const VkColorBlendAdvancedEXT * pColorBlendAdvanced ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetColorBlendAdvancedEXT( commandBuffer, firstAttachment, attachmentCount, pColorBlendAdvanced );
+      }
+
+      void vkCmdSetProvokingVertexModeEXT( VkCommandBuffer commandBuffer, VkProvokingVertexModeEXT provokingVertexMode ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetProvokingVertexModeEXT( commandBuffer, provokingVertexMode );
+      }
+
+      void vkCmdSetLineRasterizationModeEXT( VkCommandBuffer commandBuffer, VkLineRasterizationModeEXT lineRasterizationMode ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetLineRasterizationModeEXT( commandBuffer, lineRasterizationMode );
+      }
+
+      void vkCmdSetLineStippleEnableEXT( VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetLineStippleEnableEXT( commandBuffer, stippledLineEnable );
+      }
+
+      void vkCmdSetDepthClipNegativeOneToOneEXT( VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetDepthClipNegativeOneToOneEXT( commandBuffer, negativeOneToOne );
+      }
+
+      void vkCmdSetViewportWScalingEnableNV( VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetViewportWScalingEnableNV( commandBuffer, viewportWScalingEnable );
+      }
+
+      void vkCmdSetViewportSwizzleNV( VkCommandBuffer             commandBuffer,
+                                      uint32_t                    firstViewport,
+                                      uint32_t                    viewportCount,
+                                      const VkViewportSwizzleNV * pViewportSwizzles ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetViewportSwizzleNV( commandBuffer, firstViewport, viewportCount, pViewportSwizzles );
+      }
+
+      void vkCmdSetCoverageToColorEnableNV( VkCommandBuffer commandBuffer, VkBool32 coverageToColorEnable ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetCoverageToColorEnableNV( commandBuffer, coverageToColorEnable );
+      }
+
+      void vkCmdSetCoverageToColorLocationNV( VkCommandBuffer commandBuffer, uint32_t coverageToColorLocation ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetCoverageToColorLocationNV( commandBuffer, coverageToColorLocation );
+      }
+
+      void vkCmdSetCoverageModulationModeNV( VkCommandBuffer commandBuffer, VkCoverageModulationModeNV coverageModulationMode ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetCoverageModulationModeNV( commandBuffer, coverageModulationMode );
+      }
+
+      void vkCmdSetCoverageModulationTableEnableNV( VkCommandBuffer commandBuffer, VkBool32 coverageModulationTableEnable ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetCoverageModulationTableEnableNV( commandBuffer, coverageModulationTableEnable );
+      }
+
+      void vkCmdSetCoverageModulationTableNV( VkCommandBuffer commandBuffer,
+                                              uint32_t        coverageModulationTableCount,
+                                              const float *   pCoverageModulationTable ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetCoverageModulationTableNV( commandBuffer, coverageModulationTableCount, pCoverageModulationTable );
+      }
+
+      void vkCmdSetShadingRateImageEnableNV( VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetShadingRateImageEnableNV( commandBuffer, shadingRateImageEnable );
+      }
+
+      void vkCmdSetRepresentativeFragmentTestEnableNV( VkCommandBuffer commandBuffer, VkBool32 representativeFragmentTestEnable ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetRepresentativeFragmentTestEnableNV( commandBuffer, representativeFragmentTestEnable );
+      }
+
+      void vkCmdSetCoverageReductionModeNV( VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetCoverageReductionModeNV( commandBuffer, coverageReductionMode );
+      }
+
+      //=== VK_EXT_shader_module_identifier ===
+
+      void vkGetShaderModuleIdentifierEXT( VkDevice device, VkShaderModule shaderModule, VkShaderModuleIdentifierEXT * pIdentifier ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetShaderModuleIdentifierEXT( device, shaderModule, pIdentifier );
+      }
+
+      void vkGetShaderModuleCreateInfoIdentifierEXT( VkDevice                         device,
+                                                     const VkShaderModuleCreateInfo * pCreateInfo,
+                                                     VkShaderModuleIdentifierEXT *    pIdentifier ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetShaderModuleCreateInfoIdentifierEXT( device, pCreateInfo, pIdentifier );
+      }
+
+      //=== VK_NV_optical_flow ===
+
+      VkResult vkGetPhysicalDeviceOpticalFlowImageFormatsNV( VkPhysicalDevice                       physicalDevice,
+                                                             const VkOpticalFlowImageFormatInfoNV * pOpticalFlowImageFormatInfo,
+                                                             uint32_t *                             pFormatCount,
+                                                             VkOpticalFlowImageFormatPropertiesNV * pImageFormatProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceOpticalFlowImageFormatsNV( physicalDevice, pOpticalFlowImageFormatInfo, pFormatCount, pImageFormatProperties );
+      }
+
+      VkResult vkCreateOpticalFlowSessionNV( VkDevice                                 device,
+                                             const VkOpticalFlowSessionCreateInfoNV * pCreateInfo,
+                                             const VkAllocationCallbacks *            pAllocator,
+                                             VkOpticalFlowSessionNV *                 pSession ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateOpticalFlowSessionNV( device, pCreateInfo, pAllocator, pSession );
+      }
+
+      void vkDestroyOpticalFlowSessionNV( VkDevice device, VkOpticalFlowSessionNV session, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkDestroyOpticalFlowSessionNV( device, session, pAllocator );
+      }
+
+      VkResult vkBindOpticalFlowSessionImageNV( VkDevice                           device,
+                                                VkOpticalFlowSessionNV             session,
+                                                VkOpticalFlowSessionBindingPointNV bindingPoint,
+                                                VkImageView                        view,
+                                                VkImageLayout                      layout ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkBindOpticalFlowSessionImageNV( device, session, bindingPoint, view, layout );
+      }
+
+      void vkCmdOpticalFlowExecuteNV( VkCommandBuffer                    commandBuffer,
+                                      VkOpticalFlowSessionNV             session,
+                                      const VkOpticalFlowExecuteInfoNV * pExecuteInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdOpticalFlowExecuteNV( commandBuffer, session, pExecuteInfo );
+      }
+
+      //=== VK_KHR_maintenance5 ===
+
+      void vkCmdBindIndexBuffer2KHR( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType ) const
+        VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdBindIndexBuffer2KHR( commandBuffer, buffer, offset, size, indexType );
+      }
+
+      void vkGetRenderingAreaGranularityKHR( VkDevice                       device,
+                                             const VkRenderingAreaInfoKHR * pRenderingAreaInfo,
+                                             VkExtent2D *                   pGranularity ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetRenderingAreaGranularityKHR( device, pRenderingAreaInfo, pGranularity );
+      }
+
+      void vkGetDeviceImageSubresourceLayoutKHR( VkDevice                                device,
+                                                 const VkDeviceImageSubresourceInfoKHR * pInfo,
+                                                 VkSubresourceLayout2KHR *               pLayout ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetDeviceImageSubresourceLayoutKHR( device, pInfo, pLayout );
+      }
+
+      void vkGetImageSubresourceLayout2KHR( VkDevice                       device,
+                                            VkImage                        image,
+                                            const VkImageSubresource2KHR * pSubresource,
+                                            VkSubresourceLayout2KHR *      pLayout ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetImageSubresourceLayout2KHR( device, image, pSubresource, pLayout );
+      }
+
+      //=== VK_AMD_anti_lag ===
+
+      void vkAntiLagUpdateAMD( VkDevice device, const VkAntiLagDataAMD * pData ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkAntiLagUpdateAMD( device, pData );
+      }
+
+      //=== VK_EXT_shader_object ===
+
+      VkResult vkCreateShadersEXT( VkDevice                      device,
+                                   uint32_t                      createInfoCount,
+                                   const VkShaderCreateInfoEXT * pCreateInfos,
+                                   const VkAllocationCallbacks * pAllocator,
+                                   VkShaderEXT *                 pShaders ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateShadersEXT( device, createInfoCount, pCreateInfos, pAllocator, pShaders );
+      }
+
+      void vkDestroyShaderEXT( VkDevice device, VkShaderEXT shader, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkDestroyShaderEXT( device, shader, pAllocator );
+      }
+
+      VkResult vkGetShaderBinaryDataEXT( VkDevice device, VkShaderEXT shader, size_t * pDataSize, void * pData ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetShaderBinaryDataEXT( device, shader, pDataSize, pData );
+      }
+
+      void vkCmdBindShadersEXT( VkCommandBuffer               commandBuffer,
+                                uint32_t                      stageCount,
+                                const VkShaderStageFlagBits * pStages,
+                                const VkShaderEXT *           pShaders ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdBindShadersEXT( commandBuffer, stageCount, pStages, pShaders );
+      }
+
+      void vkCmdSetDepthClampRangeEXT( VkCommandBuffer              commandBuffer,
+                                       VkDepthClampModeEXT          depthClampMode,
+                                       const VkDepthClampRangeEXT * pDepthClampRange ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetDepthClampRangeEXT( commandBuffer, depthClampMode, pDepthClampRange );
+      }
+
+      //=== VK_KHR_pipeline_binary ===
+
+      VkResult vkCreatePipelineBinariesKHR( VkDevice                              device,
+                                            const VkPipelineBinaryCreateInfoKHR * pCreateInfo,
+                                            const VkAllocationCallbacks *         pAllocator,
+                                            VkPipelineBinaryHandlesInfoKHR *      pBinaries ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreatePipelineBinariesKHR( device, pCreateInfo, pAllocator, pBinaries );
+      }
+
+      void vkDestroyPipelineBinaryKHR( VkDevice device, VkPipelineBinaryKHR pipelineBinary, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkDestroyPipelineBinaryKHR( device, pipelineBinary, pAllocator );
+      }
+
+      VkResult vkGetPipelineKeyKHR( VkDevice                        device,
+                                    const VkPipelineCreateInfoKHR * pPipelineCreateInfo,
+                                    VkPipelineBinaryKeyKHR *        pPipelineKey ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPipelineKeyKHR( device, pPipelineCreateInfo, pPipelineKey );
+      }
+
+      VkResult vkGetPipelineBinaryDataKHR( VkDevice                            device,
+                                           const VkPipelineBinaryDataInfoKHR * pInfo,
+                                           VkPipelineBinaryKeyKHR *            pPipelineBinaryKey,
+                                           size_t *                            pPipelineBinaryDataSize,
+                                           void *                              pPipelineBinaryData ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPipelineBinaryDataKHR( device, pInfo, pPipelineBinaryKey, pPipelineBinaryDataSize, pPipelineBinaryData );
+      }
+
+      VkResult vkReleaseCapturedPipelineDataKHR( VkDevice                                     device,
+                                                 const VkReleaseCapturedPipelineDataInfoKHR * pInfo,
+                                                 const VkAllocationCallbacks *                pAllocator ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkReleaseCapturedPipelineDataKHR( device, pInfo, pAllocator );
+      }
+
+      //=== VK_QCOM_tile_properties ===
+
+      VkResult vkGetFramebufferTilePropertiesQCOM( VkDevice               device,
+                                                   VkFramebuffer          framebuffer,
+                                                   uint32_t *             pPropertiesCount,
+                                                   VkTilePropertiesQCOM * pProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetFramebufferTilePropertiesQCOM( device, framebuffer, pPropertiesCount, pProperties );
+      }
+
+      VkResult vkGetDynamicRenderingTilePropertiesQCOM( VkDevice                device,
+                                                        const VkRenderingInfo * pRenderingInfo,
+                                                        VkTilePropertiesQCOM *  pProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetDynamicRenderingTilePropertiesQCOM( device, pRenderingInfo, pProperties );
+      }
+
+      //=== VK_NV_low_latency2 ===
+
+      VkResult vkSetLatencySleepModeNV( VkDevice device, VkSwapchainKHR swapchain, const VkLatencySleepModeInfoNV * pSleepModeInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkSetLatencySleepModeNV( device, swapchain, pSleepModeInfo );
+      }
+
+      VkResult vkLatencySleepNV( VkDevice device, VkSwapchainKHR swapchain, const VkLatencySleepInfoNV * pSleepInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkLatencySleepNV( device, swapchain, pSleepInfo );
+      }
+
+      void vkSetLatencyMarkerNV( VkDevice device, VkSwapchainKHR swapchain, const VkSetLatencyMarkerInfoNV * pLatencyMarkerInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkSetLatencyMarkerNV( device, swapchain, pLatencyMarkerInfo );
+      }
+
+      void vkGetLatencyTimingsNV( VkDevice device, VkSwapchainKHR swapchain, VkGetLatencyMarkerInfoNV * pLatencyMarkerInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetLatencyTimingsNV( device, swapchain, pLatencyMarkerInfo );
+      }
+
+      void vkQueueNotifyOutOfBandNV( VkQueue queue, const VkOutOfBandQueueTypeInfoNV * pQueueTypeInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkQueueNotifyOutOfBandNV( queue, pQueueTypeInfo );
+      }
+
+      //=== VK_KHR_cooperative_matrix ===
+
+      VkResult vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR( VkPhysicalDevice                   physicalDevice,
+                                                                  uint32_t *                         pPropertyCount,
+                                                                  VkCooperativeMatrixPropertiesKHR * pProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR( physicalDevice, pPropertyCount, pProperties );
+      }
+
+      //=== VK_EXT_attachment_feedback_loop_dynamic_state ===
+
+      void vkCmdSetAttachmentFeedbackLoopEnableEXT( VkCommandBuffer commandBuffer, VkImageAspectFlags aspectMask ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetAttachmentFeedbackLoopEnableEXT( commandBuffer, aspectMask );
+      }
+
+#  if defined( VK_USE_PLATFORM_SCREEN_QNX )
+      //=== VK_QNX_external_memory_screen_buffer ===
+
+      VkResult vkGetScreenBufferPropertiesQNX( VkDevice                      device,
+                                               const struct _screen_buffer * buffer,
+                                               VkScreenBufferPropertiesQNX * pProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetScreenBufferPropertiesQNX( device, buffer, pProperties );
+      }
+#  endif /*VK_USE_PLATFORM_SCREEN_QNX*/
+
+      //=== VK_KHR_line_rasterization ===
+
+      void vkCmdSetLineStippleKHR( VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetLineStippleKHR( commandBuffer, lineStippleFactor, lineStipplePattern );
+      }
+
+      //=== VK_KHR_calibrated_timestamps ===
+
+      VkResult vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( VkPhysicalDevice  physicalDevice,
+                                                               uint32_t *        pTimeDomainCount,
+                                                               VkTimeDomainKHR * pTimeDomains ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( physicalDevice, pTimeDomainCount, pTimeDomains );
+      }
+
+      VkResult vkGetCalibratedTimestampsKHR( VkDevice                             device,
+                                             uint32_t                             timestampCount,
+                                             const VkCalibratedTimestampInfoKHR * pTimestampInfos,
+                                             uint64_t *                           pTimestamps,
+                                             uint64_t *                           pMaxDeviation ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetCalibratedTimestampsKHR( device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation );
+      }
+
+      //=== VK_KHR_maintenance6 ===
+
+      void vkCmdBindDescriptorSets2KHR( VkCommandBuffer commandBuffer, const VkBindDescriptorSetsInfoKHR * pBindDescriptorSetsInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdBindDescriptorSets2KHR( commandBuffer, pBindDescriptorSetsInfo );
+      }
+
+      void vkCmdPushConstants2KHR( VkCommandBuffer commandBuffer, const VkPushConstantsInfoKHR * pPushConstantsInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdPushConstants2KHR( commandBuffer, pPushConstantsInfo );
+      }
+
+      void vkCmdPushDescriptorSet2KHR( VkCommandBuffer commandBuffer, const VkPushDescriptorSetInfoKHR * pPushDescriptorSetInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdPushDescriptorSet2KHR( commandBuffer, pPushDescriptorSetInfo );
+      }
+
+      void vkCmdPushDescriptorSetWithTemplate2KHR( VkCommandBuffer                                commandBuffer,
+                                                   const VkPushDescriptorSetWithTemplateInfoKHR * pPushDescriptorSetWithTemplateInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdPushDescriptorSetWithTemplate2KHR( commandBuffer, pPushDescriptorSetWithTemplateInfo );
+      }
+
+      void vkCmdSetDescriptorBufferOffsets2EXT( VkCommandBuffer                             commandBuffer,
+                                                const VkSetDescriptorBufferOffsetsInfoEXT * pSetDescriptorBufferOffsetsInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdSetDescriptorBufferOffsets2EXT( commandBuffer, pSetDescriptorBufferOffsetsInfo );
+      }
+
+      void vkCmdBindDescriptorBufferEmbeddedSamplers2EXT(
+        VkCommandBuffer                                       commandBuffer,
+        const VkBindDescriptorBufferEmbeddedSamplersInfoEXT * pBindDescriptorBufferEmbeddedSamplersInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdBindDescriptorBufferEmbeddedSamplers2EXT( commandBuffer, pBindDescriptorBufferEmbeddedSamplersInfo );
+      }
+
+      //=== VK_EXT_device_generated_commands ===
+
+      void vkGetGeneratedCommandsMemoryRequirementsEXT( VkDevice                                             device,
+                                                        const VkGeneratedCommandsMemoryRequirementsInfoEXT * pInfo,
+                                                        VkMemoryRequirements2 *                              pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetGeneratedCommandsMemoryRequirementsEXT( device, pInfo, pMemoryRequirements );
+      }
+
+      void vkCmdPreprocessGeneratedCommandsEXT( VkCommandBuffer                    commandBuffer,
+                                                const VkGeneratedCommandsInfoEXT * pGeneratedCommandsInfo,
+                                                VkCommandBuffer                    stateCommandBuffer ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdPreprocessGeneratedCommandsEXT( commandBuffer, pGeneratedCommandsInfo, stateCommandBuffer );
+      }
+
+      void vkCmdExecuteGeneratedCommandsEXT( VkCommandBuffer                    commandBuffer,
+                                             VkBool32                           isPreprocessed,
+                                             const VkGeneratedCommandsInfoEXT * pGeneratedCommandsInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdExecuteGeneratedCommandsEXT( commandBuffer, isPreprocessed, pGeneratedCommandsInfo );
+      }
+
+      VkResult vkCreateIndirectCommandsLayoutEXT( VkDevice                                      device,
+                                                  const VkIndirectCommandsLayoutCreateInfoEXT * pCreateInfo,
+                                                  const VkAllocationCallbacks *                 pAllocator,
+                                                  VkIndirectCommandsLayoutEXT *                 pIndirectCommandsLayout ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateIndirectCommandsLayoutEXT( device, pCreateInfo, pAllocator, pIndirectCommandsLayout );
+      }
+
+      void vkDestroyIndirectCommandsLayoutEXT( VkDevice                      device,
+                                               VkIndirectCommandsLayoutEXT   indirectCommandsLayout,
+                                               const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkDestroyIndirectCommandsLayoutEXT( device, indirectCommandsLayout, pAllocator );
+      }
+
+      VkResult vkCreateIndirectExecutionSetEXT( VkDevice                                    device,
+                                                const VkIndirectExecutionSetCreateInfoEXT * pCreateInfo,
+                                                const VkAllocationCallbacks *               pAllocator,
+                                                VkIndirectExecutionSetEXT *                 pIndirectExecutionSet ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateIndirectExecutionSetEXT( device, pCreateInfo, pAllocator, pIndirectExecutionSet );
+      }
+
+      void vkDestroyIndirectExecutionSetEXT( VkDevice                      device,
+                                             VkIndirectExecutionSetEXT     indirectExecutionSet,
+                                             const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkDestroyIndirectExecutionSetEXT( device, indirectExecutionSet, pAllocator );
+      }
+
+      void vkUpdateIndirectExecutionSetPipelineEXT( VkDevice                                       device,
+                                                    VkIndirectExecutionSetEXT                      indirectExecutionSet,
+                                                    uint32_t                                       executionSetWriteCount,
+                                                    const VkWriteIndirectExecutionSetPipelineEXT * pExecutionSetWrites ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkUpdateIndirectExecutionSetPipelineEXT( device, indirectExecutionSet, executionSetWriteCount, pExecutionSetWrites );
+      }
+
+      void vkUpdateIndirectExecutionSetShaderEXT( VkDevice                                     device,
+                                                  VkIndirectExecutionSetEXT                    indirectExecutionSet,
+                                                  uint32_t                                     executionSetWriteCount,
+                                                  const VkWriteIndirectExecutionSetShaderEXT * pExecutionSetWrites ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkUpdateIndirectExecutionSetShaderEXT( device, indirectExecutionSet, executionSetWriteCount, pExecutionSetWrites );
+      }
+
+      //=== VK_NV_cooperative_matrix2 ===
+
+      VkResult vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV(
+        VkPhysicalDevice physicalDevice, uint32_t * pPropertyCount, VkCooperativeMatrixFlexibleDimensionsPropertiesNV * pProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV( physicalDevice, pPropertyCount, pProperties );
+      }
+    };
+
+    inline DispatchLoaderStatic & getDispatchLoaderStatic()
     {
-      return ::vkDestroyIndirectCommandsLayoutEXT( device, indirectCommandsLayout, pAllocator );
+      static DispatchLoaderStatic dls;
+      return dls;
     }
-
-    VkResult vkCreateIndirectExecutionSetEXT( VkDevice                                    device,
-                                              const VkIndirectExecutionSetCreateInfoEXT * pCreateInfo,
-                                              const VkAllocationCallbacks *               pAllocator,
-                                              VkIndirectExecutionSetEXT *                 pIndirectExecutionSet ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateIndirectExecutionSetEXT( device, pCreateInfo, pAllocator, pIndirectExecutionSet );
-    }
-
-    void vkDestroyIndirectExecutionSetEXT( VkDevice                      device,
-                                           VkIndirectExecutionSetEXT     indirectExecutionSet,
-                                           const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkDestroyIndirectExecutionSetEXT( device, indirectExecutionSet, pAllocator );
-    }
-
-    void vkUpdateIndirectExecutionSetPipelineEXT( VkDevice                                       device,
-                                                  VkIndirectExecutionSetEXT                      indirectExecutionSet,
-                                                  uint32_t                                       executionSetWriteCount,
-                                                  const VkWriteIndirectExecutionSetPipelineEXT * pExecutionSetWrites ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkUpdateIndirectExecutionSetPipelineEXT( device, indirectExecutionSet, executionSetWriteCount, pExecutionSetWrites );
-    }
-
-    void vkUpdateIndirectExecutionSetShaderEXT( VkDevice                                     device,
-                                                VkIndirectExecutionSetEXT                    indirectExecutionSet,
-                                                uint32_t                                     executionSetWriteCount,
-                                                const VkWriteIndirectExecutionSetShaderEXT * pExecutionSetWrites ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkUpdateIndirectExecutionSetShaderEXT( device, indirectExecutionSet, executionSetWriteCount, pExecutionSetWrites );
-    }
-
-    //=== VK_NV_cooperative_matrix2 ===
-
-    VkResult vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV(
-      VkPhysicalDevice physicalDevice, uint32_t * pPropertyCount, VkCooperativeMatrixFlexibleDimensionsPropertiesNV * pProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV( physicalDevice, pPropertyCount, pProperties );
-    }
-  };
-
-  inline ::VULKAN_HPP_NAMESPACE::DispatchLoaderStatic & getDispatchLoaderStatic()
-  {
-    static ::VULKAN_HPP_NAMESPACE::DispatchLoaderStatic dls;
-    return dls;
-  }
 #endif
 
+  }  // namespace detail
 #if ( 14 <= VULKAN_HPP_CPP_VERSION )
   using std::exchange;
 #else
@@ -6032,208 +6056,211 @@
 #if !defined( VULKAN_HPP_NO_SMART_HANDLE )
   struct AllocationCallbacks;
 
-  template <typename OwnerType, typename Dispatch>
-  class ObjectDestroy
+  namespace detail
   {
-  public:
-    ObjectDestroy() = default;
-
-    ObjectDestroy( OwnerType                                               owner,
-                   Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                   Dispatch const & dispatch                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
-      : m_owner( owner )
-      , m_allocationCallbacks( allocationCallbacks )
-      , m_dispatch( &dispatch )
+    template <typename OwnerType, typename Dispatch>
+    class ObjectDestroy
     {
-    }
+    public:
+      ObjectDestroy() = default;
 
-    OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
+      ObjectDestroy( OwnerType                                                   owner,
+                     Optional<const vk::AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                     Dispatch const & dispatch                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
+        : m_owner( owner )
+        , m_allocationCallbacks( allocationCallbacks )
+        , m_dispatch( &dispatch )
+      {
+      }
+
+      OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
+      {
+        return m_owner;
+      }
+
+      Optional<const vk::AllocationCallbacks> getAllocator() const VULKAN_HPP_NOEXCEPT
+      {
+        return m_allocationCallbacks;
+      }
+
+      Dispatch const & getDispatch() const VULKAN_HPP_NOEXCEPT
+      {
+        return *m_dispatch;
+      }
+
+    protected:
+      template <typename T>
+      void destroy( T t ) VULKAN_HPP_NOEXCEPT
+      {
+        VULKAN_HPP_ASSERT( m_owner && m_dispatch );
+        m_owner.destroy( t, m_allocationCallbacks, *m_dispatch );
+      }
+
+    private:
+      OwnerType                               m_owner               = {};
+      Optional<const vk::AllocationCallbacks> m_allocationCallbacks = nullptr;
+      Dispatch const *                        m_dispatch            = nullptr;
+    };
+
+    class NoParent;
+
+    template <typename Dispatch>
+    class ObjectDestroy<NoParent, Dispatch>
     {
-      return m_owner;
-    }
+    public:
+      ObjectDestroy() = default;
 
-    Optional<const AllocationCallbacks> getAllocator() const VULKAN_HPP_NOEXCEPT
+      ObjectDestroy( Optional<const vk::AllocationCallbacks> allocationCallbacks,
+                     Dispatch const & dispatch               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
+        : m_allocationCallbacks( allocationCallbacks )
+        , m_dispatch( &dispatch )
+      {
+      }
+
+      Optional<const vk::AllocationCallbacks> getAllocator() const VULKAN_HPP_NOEXCEPT
+      {
+        return m_allocationCallbacks;
+      }
+
+      Dispatch const & getDispatch() const VULKAN_HPP_NOEXCEPT
+      {
+        return *m_dispatch;
+      }
+
+    protected:
+      template <typename T>
+      void destroy( T t ) VULKAN_HPP_NOEXCEPT
+      {
+        VULKAN_HPP_ASSERT( m_dispatch );
+        t.destroy( m_allocationCallbacks, *m_dispatch );
+      }
+
+    private:
+      Optional<const vk::AllocationCallbacks> m_allocationCallbacks = nullptr;
+      Dispatch const *                        m_dispatch            = nullptr;
+    };
+
+    template <typename OwnerType, typename Dispatch>
+    class ObjectFree
     {
-      return m_allocationCallbacks;
-    }
+    public:
+      ObjectFree() = default;
 
-    Dispatch const & getDispatch() const VULKAN_HPP_NOEXCEPT
+      ObjectFree( OwnerType                                               owner,
+                  Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                  Dispatch const & dispatch                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
+        : m_owner( owner )
+        , m_allocationCallbacks( allocationCallbacks )
+        , m_dispatch( &dispatch )
+      {
+      }
+
+      OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
+      {
+        return m_owner;
+      }
+
+      Optional<const AllocationCallbacks> getAllocator() const VULKAN_HPP_NOEXCEPT
+      {
+        return m_allocationCallbacks;
+      }
+
+      Dispatch const & getDispatch() const VULKAN_HPP_NOEXCEPT
+      {
+        return *m_dispatch;
+      }
+
+    protected:
+      template <typename T>
+      void destroy( T t ) VULKAN_HPP_NOEXCEPT
+      {
+        VULKAN_HPP_ASSERT( m_owner && m_dispatch );
+        ( m_owner.free )( t, m_allocationCallbacks, *m_dispatch );
+      }
+
+    private:
+      OwnerType                           m_owner               = {};
+      Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
+      Dispatch const *                    m_dispatch            = nullptr;
+    };
+
+    template <typename OwnerType, typename Dispatch>
+    class ObjectRelease
     {
-      return *m_dispatch;
-    }
+    public:
+      ObjectRelease() = default;
 
-  protected:
-    template <typename T>
-    void destroy( T t ) VULKAN_HPP_NOEXCEPT
+      ObjectRelease( OwnerType owner, Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
+        : m_owner( owner )
+        , m_dispatch( &dispatch )
+      {
+      }
+
+      OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
+      {
+        return m_owner;
+      }
+
+      Dispatch const & getDispatch() const VULKAN_HPP_NOEXCEPT
+      {
+        return *m_dispatch;
+      }
+
+    protected:
+      template <typename T>
+      void destroy( T t ) VULKAN_HPP_NOEXCEPT
+      {
+        VULKAN_HPP_ASSERT( m_owner && m_dispatch );
+        m_owner.release( t, *m_dispatch );
+      }
+
+    private:
+      OwnerType        m_owner    = {};
+      Dispatch const * m_dispatch = nullptr;
+    };
+
+    template <typename OwnerType, typename PoolType, typename Dispatch>
+    class PoolFree
     {
-      VULKAN_HPP_ASSERT( m_owner && m_dispatch );
-      m_owner.destroy( t, m_allocationCallbacks, *m_dispatch );
-    }
+    public:
+      PoolFree() = default;
 
-  private:
-    OwnerType                           m_owner               = {};
-    Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
-    Dispatch const *                    m_dispatch            = nullptr;
-  };
+      PoolFree( OwnerType owner, PoolType pool, Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
+        : m_owner( owner )
+        , m_pool( pool )
+        , m_dispatch( &dispatch )
+      {
+      }
 
-  class NoParent;
+      OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
+      {
+        return m_owner;
+      }
 
-  template <typename Dispatch>
-  class ObjectDestroy<NoParent, Dispatch>
-  {
-  public:
-    ObjectDestroy() = default;
+      PoolType getPool() const VULKAN_HPP_NOEXCEPT
+      {
+        return m_pool;
+      }
 
-    ObjectDestroy( Optional<const AllocationCallbacks> allocationCallbacks,
-                   Dispatch const & dispatch           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
-      : m_allocationCallbacks( allocationCallbacks )
-      , m_dispatch( &dispatch )
-    {
-    }
+      Dispatch const & getDispatch() const VULKAN_HPP_NOEXCEPT
+      {
+        return *m_dispatch;
+      }
 
-    Optional<const AllocationCallbacks> getAllocator() const VULKAN_HPP_NOEXCEPT
-    {
-      return m_allocationCallbacks;
-    }
+    protected:
+      template <typename T>
+      void destroy( T t ) VULKAN_HPP_NOEXCEPT
+      {
+        ( m_owner.free )( m_pool, t, *m_dispatch );
+      }
 
-    Dispatch const & getDispatch() const VULKAN_HPP_NOEXCEPT
-    {
-      return *m_dispatch;
-    }
+    private:
+      OwnerType        m_owner    = OwnerType();
+      PoolType         m_pool     = PoolType();
+      Dispatch const * m_dispatch = nullptr;
+    };
 
-  protected:
-    template <typename T>
-    void destroy( T t ) VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( m_dispatch );
-      t.destroy( m_allocationCallbacks, *m_dispatch );
-    }
-
-  private:
-    Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
-    Dispatch const *                    m_dispatch            = nullptr;
-  };
-
-  template <typename OwnerType, typename Dispatch>
-  class ObjectFree
-  {
-  public:
-    ObjectFree() = default;
-
-    ObjectFree( OwnerType                                               owner,
-                Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                Dispatch const & dispatch                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
-      : m_owner( owner )
-      , m_allocationCallbacks( allocationCallbacks )
-      , m_dispatch( &dispatch )
-    {
-    }
-
-    OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
-    {
-      return m_owner;
-    }
-
-    Optional<const AllocationCallbacks> getAllocator() const VULKAN_HPP_NOEXCEPT
-    {
-      return m_allocationCallbacks;
-    }
-
-    Dispatch const & getDispatch() const VULKAN_HPP_NOEXCEPT
-    {
-      return *m_dispatch;
-    }
-
-  protected:
-    template <typename T>
-    void destroy( T t ) VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( m_owner && m_dispatch );
-      ( m_owner.free )( t, m_allocationCallbacks, *m_dispatch );
-    }
-
-  private:
-    OwnerType                           m_owner               = {};
-    Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
-    Dispatch const *                    m_dispatch            = nullptr;
-  };
-
-  template <typename OwnerType, typename Dispatch>
-  class ObjectRelease
-  {
-  public:
-    ObjectRelease() = default;
-
-    ObjectRelease( OwnerType owner, Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
-      : m_owner( owner )
-      , m_dispatch( &dispatch )
-    {
-    }
-
-    OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
-    {
-      return m_owner;
-    }
-
-    Dispatch const & getDispatch() const VULKAN_HPP_NOEXCEPT
-    {
-      return *m_dispatch;
-    }
-
-  protected:
-    template <typename T>
-    void destroy( T t ) VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( m_owner && m_dispatch );
-      m_owner.release( t, *m_dispatch );
-    }
-
-  private:
-    OwnerType        m_owner    = {};
-    Dispatch const * m_dispatch = nullptr;
-  };
-
-  template <typename OwnerType, typename PoolType, typename Dispatch>
-  class PoolFree
-  {
-  public:
-    PoolFree() = default;
-
-    PoolFree( OwnerType owner, PoolType pool, Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
-      : m_owner( owner )
-      , m_pool( pool )
-      , m_dispatch( &dispatch )
-    {
-    }
-
-    OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
-    {
-      return m_owner;
-    }
-
-    PoolType getPool() const VULKAN_HPP_NOEXCEPT
-    {
-      return m_pool;
-    }
-
-    Dispatch const & getDispatch() const VULKAN_HPP_NOEXCEPT
-    {
-      return *m_dispatch;
-    }
-
-  protected:
-    template <typename T>
-    void destroy( T t ) VULKAN_HPP_NOEXCEPT
-    {
-      ( m_owner.free )( m_pool, t, *m_dispatch );
-    }
-
-  private:
-    OwnerType        m_owner    = OwnerType();
-    PoolType         m_pool     = PoolType();
-    Dispatch const * m_dispatch = nullptr;
-  };
-
+  }     // namespace detail
 #endif  // !VULKAN_HPP_NO_SMART_HANDLE
 
   //==================
@@ -8683,6 +8710,10 @@
   VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthClampControlExtensionName = VK_EXT_DEPTH_CLAMP_CONTROL_EXTENSION_NAME;
   VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthClampControlSpecVersion   = VK_EXT_DEPTH_CLAMP_CONTROL_SPEC_VERSION;
 
+  //=== VK_HUAWEI_hdr_vivid ===
+  VULKAN_HPP_CONSTEXPR_INLINE auto HUAWEIHdrVividExtensionName = VK_HUAWEI_HDR_VIVID_EXTENSION_NAME;
+  VULKAN_HPP_CONSTEXPR_INLINE auto HUAWEIHdrVividSpecVersion   = VK_HUAWEI_HDR_VIVID_SPEC_VERSION;
+
   //=== VK_NV_cooperative_matrix2 ===
   VULKAN_HPP_CONSTEXPR_INLINE auto NVCooperativeMatrix2ExtensionName = VK_NV_COOPERATIVE_MATRIX_2_EXTENSION_NAME;
   VULKAN_HPP_CONSTEXPR_INLINE auto NVCooperativeMatrix2SpecVersion   = VK_NV_COOPERATIVE_MATRIX_2_SPEC_VERSION;
@@ -17072,6 +17103,34 @@
     };
   };
 
+  //=== VK_HUAWEI_hdr_vivid ===
+  template <>
+  struct StructExtends<PhysicalDeviceHdrVividFeaturesHUAWEI, PhysicalDeviceFeatures2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
+  template <>
+  struct StructExtends<PhysicalDeviceHdrVividFeaturesHUAWEI, DeviceCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
+  template <>
+  struct StructExtends<HdrVividDynamicMetadataHUAWEI, HdrMetadataEXT>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
   //=== VK_NV_cooperative_matrix2 ===
   template <>
   struct StructExtends<PhysicalDeviceCooperativeMatrix2FeaturesNV, PhysicalDeviceFeatures2>
@@ -17102,3792 +17161,3827 @@
 
 #endif  // VULKAN_HPP_DISABLE_ENHANCED_MODE
 
-#if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL
-  class DynamicLoader
+  namespace detail
   {
-  public:
-#  ifdef VULKAN_HPP_NO_EXCEPTIONS
-    DynamicLoader( std::string const & vulkanLibraryName = {} ) VULKAN_HPP_NOEXCEPT
-#  else
-    DynamicLoader( std::string const & vulkanLibraryName = {} )
-#  endif
+#if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL
+    class DynamicLoader
     {
-      if ( !vulkanLibraryName.empty() )
+    public:
+#  ifdef VULKAN_HPP_NO_EXCEPTIONS
+      DynamicLoader( std::string const & vulkanLibraryName = {} ) VULKAN_HPP_NOEXCEPT
+#  else
+      DynamicLoader( std::string const & vulkanLibraryName = {} )
+#  endif
       {
+        if ( !vulkanLibraryName.empty() )
+        {
 #  if defined( __unix__ ) || defined( __APPLE__ ) || defined( __QNX__ ) || defined( __Fuchsia__ )
-        m_library = dlopen( vulkanLibraryName.c_str(), RTLD_NOW | RTLD_LOCAL );
+          m_library = dlopen( vulkanLibraryName.c_str(), RTLD_NOW | RTLD_LOCAL );
 #  elif defined( _WIN32 )
-        m_library = ::LoadLibraryA( vulkanLibraryName.c_str() );
+          m_library = ::LoadLibraryA( vulkanLibraryName.c_str() );
 #  else
 #    error unsupported platform
 #  endif
-      }
-      else
-      {
+        }
+        else
+        {
 #  if defined( __unix__ ) || defined( __QNX__ ) || defined( __Fuchsia__ )
-        m_library = dlopen( "libvulkan.so", RTLD_NOW | RTLD_LOCAL );
-        if ( m_library == nullptr )
-        {
-          m_library = dlopen( "libvulkan.so.1", RTLD_NOW | RTLD_LOCAL );
-        }
+          m_library = dlopen( "libvulkan.so", RTLD_NOW | RTLD_LOCAL );
+          if ( m_library == nullptr )
+          {
+            m_library = dlopen( "libvulkan.so.1", RTLD_NOW | RTLD_LOCAL );
+          }
 #  elif defined( __APPLE__ )
-        m_library = dlopen( "libvulkan.dylib", RTLD_NOW | RTLD_LOCAL );
-        if ( m_library == nullptr )
-        {
-          m_library = dlopen( "libvulkan.1.dylib", RTLD_NOW | RTLD_LOCAL );
-        }
+          m_library = dlopen( "libvulkan.dylib", RTLD_NOW | RTLD_LOCAL );
+          if ( m_library == nullptr )
+          {
+            m_library = dlopen( "libvulkan.1.dylib", RTLD_NOW | RTLD_LOCAL );
+          }
 #  elif defined( _WIN32 )
-        m_library = ::LoadLibraryA( "vulkan-1.dll" );
+          m_library = ::LoadLibraryA( "vulkan-1.dll" );
 #  else
 #    error unsupported platform
 #  endif
-      }
+        }
 
 #  ifndef VULKAN_HPP_NO_EXCEPTIONS
-      if ( m_library == nullptr )
-      {
-        // NOTE there should be an InitializationFailedError, but msvc insists on the symbol does not exist within the scope of this function.
-        throw std::runtime_error( "Failed to load vulkan library!" );
-      }
+        if ( m_library == nullptr )
+        {
+          // NOTE there should be an InitializationFailedError, but msvc insists on the symbol does not exist within the scope of this function.
+          throw std::runtime_error( "Failed to load vulkan library!" );
+        }
 #  endif
-    }
+      }
 
-    DynamicLoader( DynamicLoader const & ) = delete;
+      DynamicLoader( DynamicLoader const & ) = delete;
 
-    DynamicLoader( DynamicLoader && other ) VULKAN_HPP_NOEXCEPT : m_library( other.m_library )
-    {
-      other.m_library = nullptr;
-    }
+      DynamicLoader( DynamicLoader && other ) VULKAN_HPP_NOEXCEPT : m_library( other.m_library )
+      {
+        other.m_library = nullptr;
+      }
 
-    DynamicLoader & operator=( DynamicLoader const & ) = delete;
+      DynamicLoader & operator=( DynamicLoader const & ) = delete;
 
-    DynamicLoader & operator=( DynamicLoader && other ) VULKAN_HPP_NOEXCEPT
-    {
-      std::swap( m_library, other.m_library );
-      return *this;
-    }
+      DynamicLoader & operator=( DynamicLoader && other ) VULKAN_HPP_NOEXCEPT
+      {
+        std::swap( m_library, other.m_library );
+        return *this;
+      }
 
-    ~DynamicLoader() VULKAN_HPP_NOEXCEPT
-    {
-      if ( m_library )
+      ~DynamicLoader() VULKAN_HPP_NOEXCEPT
+      {
+        if ( m_library )
+        {
+#  if defined( __unix__ ) || defined( __APPLE__ ) || defined( __QNX__ ) || defined( __Fuchsia__ )
+          dlclose( m_library );
+#  elif defined( _WIN32 )
+          ::FreeLibrary( m_library );
+#  else
+#    error unsupported platform
+#  endif
+        }
+      }
+
+      template <typename T>
+      T getProcAddress( const char * function ) const VULKAN_HPP_NOEXCEPT
       {
 #  if defined( __unix__ ) || defined( __APPLE__ ) || defined( __QNX__ ) || defined( __Fuchsia__ )
-        dlclose( m_library );
+        return (T)dlsym( m_library, function );
 #  elif defined( _WIN32 )
-        ::FreeLibrary( m_library );
+        return ( T )::GetProcAddress( m_library, function );
 #  else
 #    error unsupported platform
 #  endif
       }
-    }
 
-    template <typename T>
-    T getProcAddress( const char * function ) const VULKAN_HPP_NOEXCEPT
-    {
+      bool success() const VULKAN_HPP_NOEXCEPT
+      {
+        return m_library != nullptr;
+      }
+
+    private:
 #  if defined( __unix__ ) || defined( __APPLE__ ) || defined( __QNX__ ) || defined( __Fuchsia__ )
-      return (T)dlsym( m_library, function );
+      void * m_library;
 #  elif defined( _WIN32 )
-      return ( T )::GetProcAddress( m_library, function );
+      ::HINSTANCE m_library;
 #  else
 #    error unsupported platform
 #  endif
-    }
-
-    bool success() const VULKAN_HPP_NOEXCEPT
-    {
-      return m_library != nullptr;
-    }
-
-  private:
-#  if defined( __unix__ ) || defined( __APPLE__ ) || defined( __QNX__ ) || defined( __Fuchsia__ )
-    void * m_library;
-#  elif defined( _WIN32 )
-    ::HINSTANCE m_library;
-#  else
-#    error unsupported platform
-#  endif
-  };
+    };
 #endif
 
-  using PFN_dummy = void ( * )();
+    using PFN_dummy = void ( * )();
 
-  class DispatchLoaderDynamic : public DispatchLoaderBase
-  {
-  public:
-    //=== VK_VERSION_1_0 ===
-    PFN_vkCreateInstance                               vkCreateInstance                               = 0;
-    PFN_vkDestroyInstance                              vkDestroyInstance                              = 0;
-    PFN_vkEnumeratePhysicalDevices                     vkEnumeratePhysicalDevices                     = 0;
-    PFN_vkGetPhysicalDeviceFeatures                    vkGetPhysicalDeviceFeatures                    = 0;
-    PFN_vkGetPhysicalDeviceFormatProperties            vkGetPhysicalDeviceFormatProperties            = 0;
-    PFN_vkGetPhysicalDeviceImageFormatProperties       vkGetPhysicalDeviceImageFormatProperties       = 0;
-    PFN_vkGetPhysicalDeviceProperties                  vkGetPhysicalDeviceProperties                  = 0;
-    PFN_vkGetPhysicalDeviceQueueFamilyProperties       vkGetPhysicalDeviceQueueFamilyProperties       = 0;
-    PFN_vkGetPhysicalDeviceMemoryProperties            vkGetPhysicalDeviceMemoryProperties            = 0;
-    PFN_vkGetInstanceProcAddr                          vkGetInstanceProcAddr                          = 0;
-    PFN_vkGetDeviceProcAddr                            vkGetDeviceProcAddr                            = 0;
-    PFN_vkCreateDevice                                 vkCreateDevice                                 = 0;
-    PFN_vkDestroyDevice                                vkDestroyDevice                                = 0;
-    PFN_vkEnumerateInstanceExtensionProperties         vkEnumerateInstanceExtensionProperties         = 0;
-    PFN_vkEnumerateDeviceExtensionProperties           vkEnumerateDeviceExtensionProperties           = 0;
-    PFN_vkEnumerateInstanceLayerProperties             vkEnumerateInstanceLayerProperties             = 0;
-    PFN_vkEnumerateDeviceLayerProperties               vkEnumerateDeviceLayerProperties               = 0;
-    PFN_vkGetDeviceQueue                               vkGetDeviceQueue                               = 0;
-    PFN_vkQueueSubmit                                  vkQueueSubmit                                  = 0;
-    PFN_vkQueueWaitIdle                                vkQueueWaitIdle                                = 0;
-    PFN_vkDeviceWaitIdle                               vkDeviceWaitIdle                               = 0;
-    PFN_vkAllocateMemory                               vkAllocateMemory                               = 0;
-    PFN_vkFreeMemory                                   vkFreeMemory                                   = 0;
-    PFN_vkMapMemory                                    vkMapMemory                                    = 0;
-    PFN_vkUnmapMemory                                  vkUnmapMemory                                  = 0;
-    PFN_vkFlushMappedMemoryRanges                      vkFlushMappedMemoryRanges                      = 0;
-    PFN_vkInvalidateMappedMemoryRanges                 vkInvalidateMappedMemoryRanges                 = 0;
-    PFN_vkGetDeviceMemoryCommitment                    vkGetDeviceMemoryCommitment                    = 0;
-    PFN_vkBindBufferMemory                             vkBindBufferMemory                             = 0;
-    PFN_vkBindImageMemory                              vkBindImageMemory                              = 0;
-    PFN_vkGetBufferMemoryRequirements                  vkGetBufferMemoryRequirements                  = 0;
-    PFN_vkGetImageMemoryRequirements                   vkGetImageMemoryRequirements                   = 0;
-    PFN_vkGetImageSparseMemoryRequirements             vkGetImageSparseMemoryRequirements             = 0;
-    PFN_vkGetPhysicalDeviceSparseImageFormatProperties vkGetPhysicalDeviceSparseImageFormatProperties = 0;
-    PFN_vkQueueBindSparse                              vkQueueBindSparse                              = 0;
-    PFN_vkCreateFence                                  vkCreateFence                                  = 0;
-    PFN_vkDestroyFence                                 vkDestroyFence                                 = 0;
-    PFN_vkResetFences                                  vkResetFences                                  = 0;
-    PFN_vkGetFenceStatus                               vkGetFenceStatus                               = 0;
-    PFN_vkWaitForFences                                vkWaitForFences                                = 0;
-    PFN_vkCreateSemaphore                              vkCreateSemaphore                              = 0;
-    PFN_vkDestroySemaphore                             vkDestroySemaphore                             = 0;
-    PFN_vkCreateEvent                                  vkCreateEvent                                  = 0;
-    PFN_vkDestroyEvent                                 vkDestroyEvent                                 = 0;
-    PFN_vkGetEventStatus                               vkGetEventStatus                               = 0;
-    PFN_vkSetEvent                                     vkSetEvent                                     = 0;
-    PFN_vkResetEvent                                   vkResetEvent                                   = 0;
-    PFN_vkCreateQueryPool                              vkCreateQueryPool                              = 0;
-    PFN_vkDestroyQueryPool                             vkDestroyQueryPool                             = 0;
-    PFN_vkGetQueryPoolResults                          vkGetQueryPoolResults                          = 0;
-    PFN_vkCreateBuffer                                 vkCreateBuffer                                 = 0;
-    PFN_vkDestroyBuffer                                vkDestroyBuffer                                = 0;
-    PFN_vkCreateBufferView                             vkCreateBufferView                             = 0;
-    PFN_vkDestroyBufferView                            vkDestroyBufferView                            = 0;
-    PFN_vkCreateImage                                  vkCreateImage                                  = 0;
-    PFN_vkDestroyImage                                 vkDestroyImage                                 = 0;
-    PFN_vkGetImageSubresourceLayout                    vkGetImageSubresourceLayout                    = 0;
-    PFN_vkCreateImageView                              vkCreateImageView                              = 0;
-    PFN_vkDestroyImageView                             vkDestroyImageView                             = 0;
-    PFN_vkCreateShaderModule                           vkCreateShaderModule                           = 0;
-    PFN_vkDestroyShaderModule                          vkDestroyShaderModule                          = 0;
-    PFN_vkCreatePipelineCache                          vkCreatePipelineCache                          = 0;
-    PFN_vkDestroyPipelineCache                         vkDestroyPipelineCache                         = 0;
-    PFN_vkGetPipelineCacheData                         vkGetPipelineCacheData                         = 0;
-    PFN_vkMergePipelineCaches                          vkMergePipelineCaches                          = 0;
-    PFN_vkCreateGraphicsPipelines                      vkCreateGraphicsPipelines                      = 0;
-    PFN_vkCreateComputePipelines                       vkCreateComputePipelines                       = 0;
-    PFN_vkDestroyPipeline                              vkDestroyPipeline                              = 0;
-    PFN_vkCreatePipelineLayout                         vkCreatePipelineLayout                         = 0;
-    PFN_vkDestroyPipelineLayout                        vkDestroyPipelineLayout                        = 0;
-    PFN_vkCreateSampler                                vkCreateSampler                                = 0;
-    PFN_vkDestroySampler                               vkDestroySampler                               = 0;
-    PFN_vkCreateDescriptorSetLayout                    vkCreateDescriptorSetLayout                    = 0;
-    PFN_vkDestroyDescriptorSetLayout                   vkDestroyDescriptorSetLayout                   = 0;
-    PFN_vkCreateDescriptorPool                         vkCreateDescriptorPool                         = 0;
-    PFN_vkDestroyDescriptorPool                        vkDestroyDescriptorPool                        = 0;
-    PFN_vkResetDescriptorPool                          vkResetDescriptorPool                          = 0;
-    PFN_vkAllocateDescriptorSets                       vkAllocateDescriptorSets                       = 0;
-    PFN_vkFreeDescriptorSets                           vkFreeDescriptorSets                           = 0;
-    PFN_vkUpdateDescriptorSets                         vkUpdateDescriptorSets                         = 0;
-    PFN_vkCreateFramebuffer                            vkCreateFramebuffer                            = 0;
-    PFN_vkDestroyFramebuffer                           vkDestroyFramebuffer                           = 0;
-    PFN_vkCreateRenderPass                             vkCreateRenderPass                             = 0;
-    PFN_vkDestroyRenderPass                            vkDestroyRenderPass                            = 0;
-    PFN_vkGetRenderAreaGranularity                     vkGetRenderAreaGranularity                     = 0;
-    PFN_vkCreateCommandPool                            vkCreateCommandPool                            = 0;
-    PFN_vkDestroyCommandPool                           vkDestroyCommandPool                           = 0;
-    PFN_vkResetCommandPool                             vkResetCommandPool                             = 0;
-    PFN_vkAllocateCommandBuffers                       vkAllocateCommandBuffers                       = 0;
-    PFN_vkFreeCommandBuffers                           vkFreeCommandBuffers                           = 0;
-    PFN_vkBeginCommandBuffer                           vkBeginCommandBuffer                           = 0;
-    PFN_vkEndCommandBuffer                             vkEndCommandBuffer                             = 0;
-    PFN_vkResetCommandBuffer                           vkResetCommandBuffer                           = 0;
-    PFN_vkCmdBindPipeline                              vkCmdBindPipeline                              = 0;
-    PFN_vkCmdSetViewport                               vkCmdSetViewport                               = 0;
-    PFN_vkCmdSetScissor                                vkCmdSetScissor                                = 0;
-    PFN_vkCmdSetLineWidth                              vkCmdSetLineWidth                              = 0;
-    PFN_vkCmdSetDepthBias                              vkCmdSetDepthBias                              = 0;
-    PFN_vkCmdSetBlendConstants                         vkCmdSetBlendConstants                         = 0;
-    PFN_vkCmdSetDepthBounds                            vkCmdSetDepthBounds                            = 0;
-    PFN_vkCmdSetStencilCompareMask                     vkCmdSetStencilCompareMask                     = 0;
-    PFN_vkCmdSetStencilWriteMask                       vkCmdSetStencilWriteMask                       = 0;
-    PFN_vkCmdSetStencilReference                       vkCmdSetStencilReference                       = 0;
-    PFN_vkCmdBindDescriptorSets                        vkCmdBindDescriptorSets                        = 0;
-    PFN_vkCmdBindIndexBuffer                           vkCmdBindIndexBuffer                           = 0;
-    PFN_vkCmdBindVertexBuffers                         vkCmdBindVertexBuffers                         = 0;
-    PFN_vkCmdDraw                                      vkCmdDraw                                      = 0;
-    PFN_vkCmdDrawIndexed                               vkCmdDrawIndexed                               = 0;
-    PFN_vkCmdDrawIndirect                              vkCmdDrawIndirect                              = 0;
-    PFN_vkCmdDrawIndexedIndirect                       vkCmdDrawIndexedIndirect                       = 0;
-    PFN_vkCmdDispatch                                  vkCmdDispatch                                  = 0;
-    PFN_vkCmdDispatchIndirect                          vkCmdDispatchIndirect                          = 0;
-    PFN_vkCmdCopyBuffer                                vkCmdCopyBuffer                                = 0;
-    PFN_vkCmdCopyImage                                 vkCmdCopyImage                                 = 0;
-    PFN_vkCmdBlitImage                                 vkCmdBlitImage                                 = 0;
-    PFN_vkCmdCopyBufferToImage                         vkCmdCopyBufferToImage                         = 0;
-    PFN_vkCmdCopyImageToBuffer                         vkCmdCopyImageToBuffer                         = 0;
-    PFN_vkCmdUpdateBuffer                              vkCmdUpdateBuffer                              = 0;
-    PFN_vkCmdFillBuffer                                vkCmdFillBuffer                                = 0;
-    PFN_vkCmdClearColorImage                           vkCmdClearColorImage                           = 0;
-    PFN_vkCmdClearDepthStencilImage                    vkCmdClearDepthStencilImage                    = 0;
-    PFN_vkCmdClearAttachments                          vkCmdClearAttachments                          = 0;
-    PFN_vkCmdResolveImage                              vkCmdResolveImage                              = 0;
-    PFN_vkCmdSetEvent                                  vkCmdSetEvent                                  = 0;
-    PFN_vkCmdResetEvent                                vkCmdResetEvent                                = 0;
-    PFN_vkCmdWaitEvents                                vkCmdWaitEvents                                = 0;
-    PFN_vkCmdPipelineBarrier                           vkCmdPipelineBarrier                           = 0;
-    PFN_vkCmdBeginQuery                                vkCmdBeginQuery                                = 0;
-    PFN_vkCmdEndQuery                                  vkCmdEndQuery                                  = 0;
-    PFN_vkCmdResetQueryPool                            vkCmdResetQueryPool                            = 0;
-    PFN_vkCmdWriteTimestamp                            vkCmdWriteTimestamp                            = 0;
-    PFN_vkCmdCopyQueryPoolResults                      vkCmdCopyQueryPoolResults                      = 0;
-    PFN_vkCmdPushConstants                             vkCmdPushConstants                             = 0;
-    PFN_vkCmdBeginRenderPass                           vkCmdBeginRenderPass                           = 0;
-    PFN_vkCmdNextSubpass                               vkCmdNextSubpass                               = 0;
-    PFN_vkCmdEndRenderPass                             vkCmdEndRenderPass                             = 0;
-    PFN_vkCmdExecuteCommands                           vkCmdExecuteCommands                           = 0;
-
-    //=== VK_VERSION_1_1 ===
-    PFN_vkEnumerateInstanceVersion                      vkEnumerateInstanceVersion                      = 0;
-    PFN_vkBindBufferMemory2                             vkBindBufferMemory2                             = 0;
-    PFN_vkBindImageMemory2                              vkBindImageMemory2                              = 0;
-    PFN_vkGetDeviceGroupPeerMemoryFeatures              vkGetDeviceGroupPeerMemoryFeatures              = 0;
-    PFN_vkCmdSetDeviceMask                              vkCmdSetDeviceMask                              = 0;
-    PFN_vkCmdDispatchBase                               vkCmdDispatchBase                               = 0;
-    PFN_vkEnumeratePhysicalDeviceGroups                 vkEnumeratePhysicalDeviceGroups                 = 0;
-    PFN_vkGetImageMemoryRequirements2                   vkGetImageMemoryRequirements2                   = 0;
-    PFN_vkGetBufferMemoryRequirements2                  vkGetBufferMemoryRequirements2                  = 0;
-    PFN_vkGetImageSparseMemoryRequirements2             vkGetImageSparseMemoryRequirements2             = 0;
-    PFN_vkGetPhysicalDeviceFeatures2                    vkGetPhysicalDeviceFeatures2                    = 0;
-    PFN_vkGetPhysicalDeviceProperties2                  vkGetPhysicalDeviceProperties2                  = 0;
-    PFN_vkGetPhysicalDeviceFormatProperties2            vkGetPhysicalDeviceFormatProperties2            = 0;
-    PFN_vkGetPhysicalDeviceImageFormatProperties2       vkGetPhysicalDeviceImageFormatProperties2       = 0;
-    PFN_vkGetPhysicalDeviceQueueFamilyProperties2       vkGetPhysicalDeviceQueueFamilyProperties2       = 0;
-    PFN_vkGetPhysicalDeviceMemoryProperties2            vkGetPhysicalDeviceMemoryProperties2            = 0;
-    PFN_vkGetPhysicalDeviceSparseImageFormatProperties2 vkGetPhysicalDeviceSparseImageFormatProperties2 = 0;
-    PFN_vkTrimCommandPool                               vkTrimCommandPool                               = 0;
-    PFN_vkGetDeviceQueue2                               vkGetDeviceQueue2                               = 0;
-    PFN_vkCreateSamplerYcbcrConversion                  vkCreateSamplerYcbcrConversion                  = 0;
-    PFN_vkDestroySamplerYcbcrConversion                 vkDestroySamplerYcbcrConversion                 = 0;
-    PFN_vkCreateDescriptorUpdateTemplate                vkCreateDescriptorUpdateTemplate                = 0;
-    PFN_vkDestroyDescriptorUpdateTemplate               vkDestroyDescriptorUpdateTemplate               = 0;
-    PFN_vkUpdateDescriptorSetWithTemplate               vkUpdateDescriptorSetWithTemplate               = 0;
-    PFN_vkGetPhysicalDeviceExternalBufferProperties     vkGetPhysicalDeviceExternalBufferProperties     = 0;
-    PFN_vkGetPhysicalDeviceExternalFenceProperties      vkGetPhysicalDeviceExternalFenceProperties      = 0;
-    PFN_vkGetPhysicalDeviceExternalSemaphoreProperties  vkGetPhysicalDeviceExternalSemaphoreProperties  = 0;
-    PFN_vkGetDescriptorSetLayoutSupport                 vkGetDescriptorSetLayoutSupport                 = 0;
-
-    //=== VK_VERSION_1_2 ===
-    PFN_vkCmdDrawIndirectCount                vkCmdDrawIndirectCount                = 0;
-    PFN_vkCmdDrawIndexedIndirectCount         vkCmdDrawIndexedIndirectCount         = 0;
-    PFN_vkCreateRenderPass2                   vkCreateRenderPass2                   = 0;
-    PFN_vkCmdBeginRenderPass2                 vkCmdBeginRenderPass2                 = 0;
-    PFN_vkCmdNextSubpass2                     vkCmdNextSubpass2                     = 0;
-    PFN_vkCmdEndRenderPass2                   vkCmdEndRenderPass2                   = 0;
-    PFN_vkResetQueryPool                      vkResetQueryPool                      = 0;
-    PFN_vkGetSemaphoreCounterValue            vkGetSemaphoreCounterValue            = 0;
-    PFN_vkWaitSemaphores                      vkWaitSemaphores                      = 0;
-    PFN_vkSignalSemaphore                     vkSignalSemaphore                     = 0;
-    PFN_vkGetBufferDeviceAddress              vkGetBufferDeviceAddress              = 0;
-    PFN_vkGetBufferOpaqueCaptureAddress       vkGetBufferOpaqueCaptureAddress       = 0;
-    PFN_vkGetDeviceMemoryOpaqueCaptureAddress vkGetDeviceMemoryOpaqueCaptureAddress = 0;
-
-    //=== VK_VERSION_1_3 ===
-    PFN_vkGetPhysicalDeviceToolProperties        vkGetPhysicalDeviceToolProperties        = 0;
-    PFN_vkCreatePrivateDataSlot                  vkCreatePrivateDataSlot                  = 0;
-    PFN_vkDestroyPrivateDataSlot                 vkDestroyPrivateDataSlot                 = 0;
-    PFN_vkSetPrivateData                         vkSetPrivateData                         = 0;
-    PFN_vkGetPrivateData                         vkGetPrivateData                         = 0;
-    PFN_vkCmdSetEvent2                           vkCmdSetEvent2                           = 0;
-    PFN_vkCmdResetEvent2                         vkCmdResetEvent2                         = 0;
-    PFN_vkCmdWaitEvents2                         vkCmdWaitEvents2                         = 0;
-    PFN_vkCmdPipelineBarrier2                    vkCmdPipelineBarrier2                    = 0;
-    PFN_vkCmdWriteTimestamp2                     vkCmdWriteTimestamp2                     = 0;
-    PFN_vkQueueSubmit2                           vkQueueSubmit2                           = 0;
-    PFN_vkCmdCopyBuffer2                         vkCmdCopyBuffer2                         = 0;
-    PFN_vkCmdCopyImage2                          vkCmdCopyImage2                          = 0;
-    PFN_vkCmdCopyBufferToImage2                  vkCmdCopyBufferToImage2                  = 0;
-    PFN_vkCmdCopyImageToBuffer2                  vkCmdCopyImageToBuffer2                  = 0;
-    PFN_vkCmdBlitImage2                          vkCmdBlitImage2                          = 0;
-    PFN_vkCmdResolveImage2                       vkCmdResolveImage2                       = 0;
-    PFN_vkCmdBeginRendering                      vkCmdBeginRendering                      = 0;
-    PFN_vkCmdEndRendering                        vkCmdEndRendering                        = 0;
-    PFN_vkCmdSetCullMode                         vkCmdSetCullMode                         = 0;
-    PFN_vkCmdSetFrontFace                        vkCmdSetFrontFace                        = 0;
-    PFN_vkCmdSetPrimitiveTopology                vkCmdSetPrimitiveTopology                = 0;
-    PFN_vkCmdSetViewportWithCount                vkCmdSetViewportWithCount                = 0;
-    PFN_vkCmdSetScissorWithCount                 vkCmdSetScissorWithCount                 = 0;
-    PFN_vkCmdBindVertexBuffers2                  vkCmdBindVertexBuffers2                  = 0;
-    PFN_vkCmdSetDepthTestEnable                  vkCmdSetDepthTestEnable                  = 0;
-    PFN_vkCmdSetDepthWriteEnable                 vkCmdSetDepthWriteEnable                 = 0;
-    PFN_vkCmdSetDepthCompareOp                   vkCmdSetDepthCompareOp                   = 0;
-    PFN_vkCmdSetDepthBoundsTestEnable            vkCmdSetDepthBoundsTestEnable            = 0;
-    PFN_vkCmdSetStencilTestEnable                vkCmdSetStencilTestEnable                = 0;
-    PFN_vkCmdSetStencilOp                        vkCmdSetStencilOp                        = 0;
-    PFN_vkCmdSetRasterizerDiscardEnable          vkCmdSetRasterizerDiscardEnable          = 0;
-    PFN_vkCmdSetDepthBiasEnable                  vkCmdSetDepthBiasEnable                  = 0;
-    PFN_vkCmdSetPrimitiveRestartEnable           vkCmdSetPrimitiveRestartEnable           = 0;
-    PFN_vkGetDeviceBufferMemoryRequirements      vkGetDeviceBufferMemoryRequirements      = 0;
-    PFN_vkGetDeviceImageMemoryRequirements       vkGetDeviceImageMemoryRequirements       = 0;
-    PFN_vkGetDeviceImageSparseMemoryRequirements vkGetDeviceImageSparseMemoryRequirements = 0;
-
-    //=== VK_KHR_surface ===
-    PFN_vkDestroySurfaceKHR                       vkDestroySurfaceKHR                       = 0;
-    PFN_vkGetPhysicalDeviceSurfaceSupportKHR      vkGetPhysicalDeviceSurfaceSupportKHR      = 0;
-    PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR vkGetPhysicalDeviceSurfaceCapabilitiesKHR = 0;
-    PFN_vkGetPhysicalDeviceSurfaceFormatsKHR      vkGetPhysicalDeviceSurfaceFormatsKHR      = 0;
-    PFN_vkGetPhysicalDeviceSurfacePresentModesKHR vkGetPhysicalDeviceSurfacePresentModesKHR = 0;
-
-    //=== VK_KHR_swapchain ===
-    PFN_vkCreateSwapchainKHR                    vkCreateSwapchainKHR                    = 0;
-    PFN_vkDestroySwapchainKHR                   vkDestroySwapchainKHR                   = 0;
-    PFN_vkGetSwapchainImagesKHR                 vkGetSwapchainImagesKHR                 = 0;
-    PFN_vkAcquireNextImageKHR                   vkAcquireNextImageKHR                   = 0;
-    PFN_vkQueuePresentKHR                       vkQueuePresentKHR                       = 0;
-    PFN_vkGetDeviceGroupPresentCapabilitiesKHR  vkGetDeviceGroupPresentCapabilitiesKHR  = 0;
-    PFN_vkGetDeviceGroupSurfacePresentModesKHR  vkGetDeviceGroupSurfacePresentModesKHR  = 0;
-    PFN_vkGetPhysicalDevicePresentRectanglesKHR vkGetPhysicalDevicePresentRectanglesKHR = 0;
-    PFN_vkAcquireNextImage2KHR                  vkAcquireNextImage2KHR                  = 0;
-
-    //=== VK_KHR_display ===
-    PFN_vkGetPhysicalDeviceDisplayPropertiesKHR      vkGetPhysicalDeviceDisplayPropertiesKHR      = 0;
-    PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR vkGetPhysicalDeviceDisplayPlanePropertiesKHR = 0;
-    PFN_vkGetDisplayPlaneSupportedDisplaysKHR        vkGetDisplayPlaneSupportedDisplaysKHR        = 0;
-    PFN_vkGetDisplayModePropertiesKHR                vkGetDisplayModePropertiesKHR                = 0;
-    PFN_vkCreateDisplayModeKHR                       vkCreateDisplayModeKHR                       = 0;
-    PFN_vkGetDisplayPlaneCapabilitiesKHR             vkGetDisplayPlaneCapabilitiesKHR             = 0;
-    PFN_vkCreateDisplayPlaneSurfaceKHR               vkCreateDisplayPlaneSurfaceKHR               = 0;
-
-    //=== VK_KHR_display_swapchain ===
-    PFN_vkCreateSharedSwapchainsKHR vkCreateSharedSwapchainsKHR = 0;
-
-#if defined( VK_USE_PLATFORM_XLIB_KHR )
-    //=== VK_KHR_xlib_surface ===
-    PFN_vkCreateXlibSurfaceKHR                        vkCreateXlibSurfaceKHR                        = 0;
-    PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR vkGetPhysicalDeviceXlibPresentationSupportKHR = 0;
-#else
-    PFN_dummy vkCreateXlibSurfaceKHR_placeholder                            = 0;
-    PFN_dummy vkGetPhysicalDeviceXlibPresentationSupportKHR_placeholder     = 0;
-#endif /*VK_USE_PLATFORM_XLIB_KHR*/
-
-#if defined( VK_USE_PLATFORM_XCB_KHR )
-    //=== VK_KHR_xcb_surface ===
-    PFN_vkCreateXcbSurfaceKHR                        vkCreateXcbSurfaceKHR                        = 0;
-    PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR vkGetPhysicalDeviceXcbPresentationSupportKHR = 0;
-#else
-    PFN_dummy vkCreateXcbSurfaceKHR_placeholder                             = 0;
-    PFN_dummy vkGetPhysicalDeviceXcbPresentationSupportKHR_placeholder      = 0;
-#endif /*VK_USE_PLATFORM_XCB_KHR*/
-
-#if defined( VK_USE_PLATFORM_WAYLAND_KHR )
-    //=== VK_KHR_wayland_surface ===
-    PFN_vkCreateWaylandSurfaceKHR                        vkCreateWaylandSurfaceKHR                        = 0;
-    PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR vkGetPhysicalDeviceWaylandPresentationSupportKHR = 0;
-#else
-    PFN_dummy vkCreateWaylandSurfaceKHR_placeholder                         = 0;
-    PFN_dummy vkGetPhysicalDeviceWaylandPresentationSupportKHR_placeholder  = 0;
-#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
-
-#if defined( VK_USE_PLATFORM_ANDROID_KHR )
-    //=== VK_KHR_android_surface ===
-    PFN_vkCreateAndroidSurfaceKHR vkCreateAndroidSurfaceKHR = 0;
-#else
-    PFN_dummy vkCreateAndroidSurfaceKHR_placeholder                         = 0;
-#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
-
-#if defined( VK_USE_PLATFORM_WIN32_KHR )
-    //=== VK_KHR_win32_surface ===
-    PFN_vkCreateWin32SurfaceKHR                        vkCreateWin32SurfaceKHR                        = 0;
-    PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR vkGetPhysicalDeviceWin32PresentationSupportKHR = 0;
-#else
-    PFN_dummy vkCreateWin32SurfaceKHR_placeholder                           = 0;
-    PFN_dummy vkGetPhysicalDeviceWin32PresentationSupportKHR_placeholder    = 0;
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-    //=== VK_EXT_debug_report ===
-    PFN_vkCreateDebugReportCallbackEXT  vkCreateDebugReportCallbackEXT  = 0;
-    PFN_vkDestroyDebugReportCallbackEXT vkDestroyDebugReportCallbackEXT = 0;
-    PFN_vkDebugReportMessageEXT         vkDebugReportMessageEXT         = 0;
-
-    //=== VK_EXT_debug_marker ===
-    PFN_vkDebugMarkerSetObjectTagEXT  vkDebugMarkerSetObjectTagEXT  = 0;
-    PFN_vkDebugMarkerSetObjectNameEXT vkDebugMarkerSetObjectNameEXT = 0;
-    PFN_vkCmdDebugMarkerBeginEXT      vkCmdDebugMarkerBeginEXT      = 0;
-    PFN_vkCmdDebugMarkerEndEXT        vkCmdDebugMarkerEndEXT        = 0;
-    PFN_vkCmdDebugMarkerInsertEXT     vkCmdDebugMarkerInsertEXT     = 0;
-
-    //=== VK_KHR_video_queue ===
-    PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR     vkGetPhysicalDeviceVideoCapabilitiesKHR     = 0;
-    PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR vkGetPhysicalDeviceVideoFormatPropertiesKHR = 0;
-    PFN_vkCreateVideoSessionKHR                     vkCreateVideoSessionKHR                     = 0;
-    PFN_vkDestroyVideoSessionKHR                    vkDestroyVideoSessionKHR                    = 0;
-    PFN_vkGetVideoSessionMemoryRequirementsKHR      vkGetVideoSessionMemoryRequirementsKHR      = 0;
-    PFN_vkBindVideoSessionMemoryKHR                 vkBindVideoSessionMemoryKHR                 = 0;
-    PFN_vkCreateVideoSessionParametersKHR           vkCreateVideoSessionParametersKHR           = 0;
-    PFN_vkUpdateVideoSessionParametersKHR           vkUpdateVideoSessionParametersKHR           = 0;
-    PFN_vkDestroyVideoSessionParametersKHR          vkDestroyVideoSessionParametersKHR          = 0;
-    PFN_vkCmdBeginVideoCodingKHR                    vkCmdBeginVideoCodingKHR                    = 0;
-    PFN_vkCmdEndVideoCodingKHR                      vkCmdEndVideoCodingKHR                      = 0;
-    PFN_vkCmdControlVideoCodingKHR                  vkCmdControlVideoCodingKHR                  = 0;
-
-    //=== VK_KHR_video_decode_queue ===
-    PFN_vkCmdDecodeVideoKHR vkCmdDecodeVideoKHR = 0;
-
-    //=== VK_EXT_transform_feedback ===
-    PFN_vkCmdBindTransformFeedbackBuffersEXT vkCmdBindTransformFeedbackBuffersEXT = 0;
-    PFN_vkCmdBeginTransformFeedbackEXT       vkCmdBeginTransformFeedbackEXT       = 0;
-    PFN_vkCmdEndTransformFeedbackEXT         vkCmdEndTransformFeedbackEXT         = 0;
-    PFN_vkCmdBeginQueryIndexedEXT            vkCmdBeginQueryIndexedEXT            = 0;
-    PFN_vkCmdEndQueryIndexedEXT              vkCmdEndQueryIndexedEXT              = 0;
-    PFN_vkCmdDrawIndirectByteCountEXT        vkCmdDrawIndirectByteCountEXT        = 0;
-
-    //=== VK_NVX_binary_import ===
-    PFN_vkCreateCuModuleNVX    vkCreateCuModuleNVX    = 0;
-    PFN_vkCreateCuFunctionNVX  vkCreateCuFunctionNVX  = 0;
-    PFN_vkDestroyCuModuleNVX   vkDestroyCuModuleNVX   = 0;
-    PFN_vkDestroyCuFunctionNVX vkDestroyCuFunctionNVX = 0;
-    PFN_vkCmdCuLaunchKernelNVX vkCmdCuLaunchKernelNVX = 0;
-
-    //=== VK_NVX_image_view_handle ===
-    PFN_vkGetImageViewHandleNVX  vkGetImageViewHandleNVX  = 0;
-    PFN_vkGetImageViewAddressNVX vkGetImageViewAddressNVX = 0;
-
-    //=== VK_AMD_draw_indirect_count ===
-    PFN_vkCmdDrawIndirectCountAMD        vkCmdDrawIndirectCountAMD        = 0;
-    PFN_vkCmdDrawIndexedIndirectCountAMD vkCmdDrawIndexedIndirectCountAMD = 0;
-
-    //=== VK_AMD_shader_info ===
-    PFN_vkGetShaderInfoAMD vkGetShaderInfoAMD = 0;
-
-    //=== VK_KHR_dynamic_rendering ===
-    PFN_vkCmdBeginRenderingKHR vkCmdBeginRenderingKHR = 0;
-    PFN_vkCmdEndRenderingKHR   vkCmdEndRenderingKHR   = 0;
-
-#if defined( VK_USE_PLATFORM_GGP )
-    //=== VK_GGP_stream_descriptor_surface ===
-    PFN_vkCreateStreamDescriptorSurfaceGGP vkCreateStreamDescriptorSurfaceGGP = 0;
-#else
-    PFN_dummy vkCreateStreamDescriptorSurfaceGGP_placeholder                = 0;
-#endif /*VK_USE_PLATFORM_GGP*/
-
-    //=== VK_NV_external_memory_capabilities ===
-    PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV vkGetPhysicalDeviceExternalImageFormatPropertiesNV = 0;
-
-#if defined( VK_USE_PLATFORM_WIN32_KHR )
-    //=== VK_NV_external_memory_win32 ===
-    PFN_vkGetMemoryWin32HandleNV vkGetMemoryWin32HandleNV = 0;
-#else
-    PFN_dummy vkGetMemoryWin32HandleNV_placeholder                          = 0;
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-    //=== VK_KHR_get_physical_device_properties2 ===
-    PFN_vkGetPhysicalDeviceFeatures2KHR                    vkGetPhysicalDeviceFeatures2KHR                    = 0;
-    PFN_vkGetPhysicalDeviceProperties2KHR                  vkGetPhysicalDeviceProperties2KHR                  = 0;
-    PFN_vkGetPhysicalDeviceFormatProperties2KHR            vkGetPhysicalDeviceFormatProperties2KHR            = 0;
-    PFN_vkGetPhysicalDeviceImageFormatProperties2KHR       vkGetPhysicalDeviceImageFormatProperties2KHR       = 0;
-    PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR       vkGetPhysicalDeviceQueueFamilyProperties2KHR       = 0;
-    PFN_vkGetPhysicalDeviceMemoryProperties2KHR            vkGetPhysicalDeviceMemoryProperties2KHR            = 0;
-    PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR vkGetPhysicalDeviceSparseImageFormatProperties2KHR = 0;
-
-    //=== VK_KHR_device_group ===
-    PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR vkGetDeviceGroupPeerMemoryFeaturesKHR = 0;
-    PFN_vkCmdSetDeviceMaskKHR                 vkCmdSetDeviceMaskKHR                 = 0;
-    PFN_vkCmdDispatchBaseKHR                  vkCmdDispatchBaseKHR                  = 0;
-
-#if defined( VK_USE_PLATFORM_VI_NN )
-    //=== VK_NN_vi_surface ===
-    PFN_vkCreateViSurfaceNN vkCreateViSurfaceNN = 0;
-#else
-    PFN_dummy vkCreateViSurfaceNN_placeholder                               = 0;
-#endif /*VK_USE_PLATFORM_VI_NN*/
-
-    //=== VK_KHR_maintenance1 ===
-    PFN_vkTrimCommandPoolKHR vkTrimCommandPoolKHR = 0;
-
-    //=== VK_KHR_device_group_creation ===
-    PFN_vkEnumeratePhysicalDeviceGroupsKHR vkEnumeratePhysicalDeviceGroupsKHR = 0;
-
-    //=== VK_KHR_external_memory_capabilities ===
-    PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR vkGetPhysicalDeviceExternalBufferPropertiesKHR = 0;
-
-#if defined( VK_USE_PLATFORM_WIN32_KHR )
-    //=== VK_KHR_external_memory_win32 ===
-    PFN_vkGetMemoryWin32HandleKHR           vkGetMemoryWin32HandleKHR           = 0;
-    PFN_vkGetMemoryWin32HandlePropertiesKHR vkGetMemoryWin32HandlePropertiesKHR = 0;
-#else
-    PFN_dummy vkGetMemoryWin32HandleKHR_placeholder                         = 0;
-    PFN_dummy vkGetMemoryWin32HandlePropertiesKHR_placeholder               = 0;
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-    //=== VK_KHR_external_memory_fd ===
-    PFN_vkGetMemoryFdKHR           vkGetMemoryFdKHR           = 0;
-    PFN_vkGetMemoryFdPropertiesKHR vkGetMemoryFdPropertiesKHR = 0;
-
-    //=== VK_KHR_external_semaphore_capabilities ===
-    PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = 0;
-
-#if defined( VK_USE_PLATFORM_WIN32_KHR )
-    //=== VK_KHR_external_semaphore_win32 ===
-    PFN_vkImportSemaphoreWin32HandleKHR vkImportSemaphoreWin32HandleKHR = 0;
-    PFN_vkGetSemaphoreWin32HandleKHR    vkGetSemaphoreWin32HandleKHR    = 0;
-#else
-    PFN_dummy vkImportSemaphoreWin32HandleKHR_placeholder                   = 0;
-    PFN_dummy vkGetSemaphoreWin32HandleKHR_placeholder                      = 0;
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-    //=== VK_KHR_external_semaphore_fd ===
-    PFN_vkImportSemaphoreFdKHR vkImportSemaphoreFdKHR = 0;
-    PFN_vkGetSemaphoreFdKHR    vkGetSemaphoreFdKHR    = 0;
-
-    //=== VK_KHR_push_descriptor ===
-    PFN_vkCmdPushDescriptorSetKHR             vkCmdPushDescriptorSetKHR             = 0;
-    PFN_vkCmdPushDescriptorSetWithTemplateKHR vkCmdPushDescriptorSetWithTemplateKHR = 0;
-
-    //=== VK_EXT_conditional_rendering ===
-    PFN_vkCmdBeginConditionalRenderingEXT vkCmdBeginConditionalRenderingEXT = 0;
-    PFN_vkCmdEndConditionalRenderingEXT   vkCmdEndConditionalRenderingEXT   = 0;
-
-    //=== VK_KHR_descriptor_update_template ===
-    PFN_vkCreateDescriptorUpdateTemplateKHR  vkCreateDescriptorUpdateTemplateKHR  = 0;
-    PFN_vkDestroyDescriptorUpdateTemplateKHR vkDestroyDescriptorUpdateTemplateKHR = 0;
-    PFN_vkUpdateDescriptorSetWithTemplateKHR vkUpdateDescriptorSetWithTemplateKHR = 0;
-
-    //=== VK_NV_clip_space_w_scaling ===
-    PFN_vkCmdSetViewportWScalingNV vkCmdSetViewportWScalingNV = 0;
-
-    //=== VK_EXT_direct_mode_display ===
-    PFN_vkReleaseDisplayEXT vkReleaseDisplayEXT = 0;
-
-#if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
-    //=== VK_EXT_acquire_xlib_display ===
-    PFN_vkAcquireXlibDisplayEXT    vkAcquireXlibDisplayEXT    = 0;
-    PFN_vkGetRandROutputDisplayEXT vkGetRandROutputDisplayEXT = 0;
-#else
-    PFN_dummy vkAcquireXlibDisplayEXT_placeholder                           = 0;
-    PFN_dummy vkGetRandROutputDisplayEXT_placeholder                        = 0;
-#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
-
-    //=== VK_EXT_display_surface_counter ===
-    PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT vkGetPhysicalDeviceSurfaceCapabilities2EXT = 0;
-
-    //=== VK_EXT_display_control ===
-    PFN_vkDisplayPowerControlEXT  vkDisplayPowerControlEXT  = 0;
-    PFN_vkRegisterDeviceEventEXT  vkRegisterDeviceEventEXT  = 0;
-    PFN_vkRegisterDisplayEventEXT vkRegisterDisplayEventEXT = 0;
-    PFN_vkGetSwapchainCounterEXT  vkGetSwapchainCounterEXT  = 0;
-
-    //=== VK_GOOGLE_display_timing ===
-    PFN_vkGetRefreshCycleDurationGOOGLE   vkGetRefreshCycleDurationGOOGLE   = 0;
-    PFN_vkGetPastPresentationTimingGOOGLE vkGetPastPresentationTimingGOOGLE = 0;
-
-    //=== VK_EXT_discard_rectangles ===
-    PFN_vkCmdSetDiscardRectangleEXT       vkCmdSetDiscardRectangleEXT       = 0;
-    PFN_vkCmdSetDiscardRectangleEnableEXT vkCmdSetDiscardRectangleEnableEXT = 0;
-    PFN_vkCmdSetDiscardRectangleModeEXT   vkCmdSetDiscardRectangleModeEXT   = 0;
-
-    //=== VK_EXT_hdr_metadata ===
-    PFN_vkSetHdrMetadataEXT vkSetHdrMetadataEXT = 0;
-
-    //=== VK_KHR_create_renderpass2 ===
-    PFN_vkCreateRenderPass2KHR   vkCreateRenderPass2KHR   = 0;
-    PFN_vkCmdBeginRenderPass2KHR vkCmdBeginRenderPass2KHR = 0;
-    PFN_vkCmdNextSubpass2KHR     vkCmdNextSubpass2KHR     = 0;
-    PFN_vkCmdEndRenderPass2KHR   vkCmdEndRenderPass2KHR   = 0;
-
-    //=== VK_KHR_shared_presentable_image ===
-    PFN_vkGetSwapchainStatusKHR vkGetSwapchainStatusKHR = 0;
-
-    //=== VK_KHR_external_fence_capabilities ===
-    PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR vkGetPhysicalDeviceExternalFencePropertiesKHR = 0;
-
-#if defined( VK_USE_PLATFORM_WIN32_KHR )
-    //=== VK_KHR_external_fence_win32 ===
-    PFN_vkImportFenceWin32HandleKHR vkImportFenceWin32HandleKHR = 0;
-    PFN_vkGetFenceWin32HandleKHR    vkGetFenceWin32HandleKHR    = 0;
-#else
-    PFN_dummy vkImportFenceWin32HandleKHR_placeholder                       = 0;
-    PFN_dummy vkGetFenceWin32HandleKHR_placeholder                          = 0;
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-    //=== VK_KHR_external_fence_fd ===
-    PFN_vkImportFenceFdKHR vkImportFenceFdKHR = 0;
-    PFN_vkGetFenceFdKHR    vkGetFenceFdKHR    = 0;
-
-    //=== VK_KHR_performance_query ===
-    PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = 0;
-    PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR         vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR         = 0;
-    PFN_vkAcquireProfilingLockKHR                                       vkAcquireProfilingLockKHR                                       = 0;
-    PFN_vkReleaseProfilingLockKHR                                       vkReleaseProfilingLockKHR                                       = 0;
-
-    //=== VK_KHR_get_surface_capabilities2 ===
-    PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR vkGetPhysicalDeviceSurfaceCapabilities2KHR = 0;
-    PFN_vkGetPhysicalDeviceSurfaceFormats2KHR      vkGetPhysicalDeviceSurfaceFormats2KHR      = 0;
-
-    //=== VK_KHR_get_display_properties2 ===
-    PFN_vkGetPhysicalDeviceDisplayProperties2KHR      vkGetPhysicalDeviceDisplayProperties2KHR      = 0;
-    PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR vkGetPhysicalDeviceDisplayPlaneProperties2KHR = 0;
-    PFN_vkGetDisplayModeProperties2KHR                vkGetDisplayModeProperties2KHR                = 0;
-    PFN_vkGetDisplayPlaneCapabilities2KHR             vkGetDisplayPlaneCapabilities2KHR             = 0;
-
-#if defined( VK_USE_PLATFORM_IOS_MVK )
-    //=== VK_MVK_ios_surface ===
-    PFN_vkCreateIOSSurfaceMVK vkCreateIOSSurfaceMVK = 0;
-#else
-    PFN_dummy vkCreateIOSSurfaceMVK_placeholder                             = 0;
-#endif /*VK_USE_PLATFORM_IOS_MVK*/
-
-#if defined( VK_USE_PLATFORM_MACOS_MVK )
-    //=== VK_MVK_macos_surface ===
-    PFN_vkCreateMacOSSurfaceMVK vkCreateMacOSSurfaceMVK = 0;
-#else
-    PFN_dummy vkCreateMacOSSurfaceMVK_placeholder                           = 0;
-#endif /*VK_USE_PLATFORM_MACOS_MVK*/
-
-    //=== VK_EXT_debug_utils ===
-    PFN_vkSetDebugUtilsObjectNameEXT    vkSetDebugUtilsObjectNameEXT    = 0;
-    PFN_vkSetDebugUtilsObjectTagEXT     vkSetDebugUtilsObjectTagEXT     = 0;
-    PFN_vkQueueBeginDebugUtilsLabelEXT  vkQueueBeginDebugUtilsLabelEXT  = 0;
-    PFN_vkQueueEndDebugUtilsLabelEXT    vkQueueEndDebugUtilsLabelEXT    = 0;
-    PFN_vkQueueInsertDebugUtilsLabelEXT vkQueueInsertDebugUtilsLabelEXT = 0;
-    PFN_vkCmdBeginDebugUtilsLabelEXT    vkCmdBeginDebugUtilsLabelEXT    = 0;
-    PFN_vkCmdEndDebugUtilsLabelEXT      vkCmdEndDebugUtilsLabelEXT      = 0;
-    PFN_vkCmdInsertDebugUtilsLabelEXT   vkCmdInsertDebugUtilsLabelEXT   = 0;
-    PFN_vkCreateDebugUtilsMessengerEXT  vkCreateDebugUtilsMessengerEXT  = 0;
-    PFN_vkDestroyDebugUtilsMessengerEXT vkDestroyDebugUtilsMessengerEXT = 0;
-    PFN_vkSubmitDebugUtilsMessageEXT    vkSubmitDebugUtilsMessageEXT    = 0;
-
-#if defined( VK_USE_PLATFORM_ANDROID_KHR )
-    //=== VK_ANDROID_external_memory_android_hardware_buffer ===
-    PFN_vkGetAndroidHardwareBufferPropertiesANDROID vkGetAndroidHardwareBufferPropertiesANDROID = 0;
-    PFN_vkGetMemoryAndroidHardwareBufferANDROID     vkGetMemoryAndroidHardwareBufferANDROID     = 0;
-#else
-    PFN_dummy vkGetAndroidHardwareBufferPropertiesANDROID_placeholder       = 0;
-    PFN_dummy vkGetMemoryAndroidHardwareBufferANDROID_placeholder           = 0;
-#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
-
-#if defined( VK_ENABLE_BETA_EXTENSIONS )
-    //=== VK_AMDX_shader_enqueue ===
-    PFN_vkCreateExecutionGraphPipelinesAMDX        vkCreateExecutionGraphPipelinesAMDX        = 0;
-    PFN_vkGetExecutionGraphPipelineScratchSizeAMDX vkGetExecutionGraphPipelineScratchSizeAMDX = 0;
-    PFN_vkGetExecutionGraphPipelineNodeIndexAMDX   vkGetExecutionGraphPipelineNodeIndexAMDX   = 0;
-    PFN_vkCmdInitializeGraphScratchMemoryAMDX      vkCmdInitializeGraphScratchMemoryAMDX      = 0;
-    PFN_vkCmdDispatchGraphAMDX                     vkCmdDispatchGraphAMDX                     = 0;
-    PFN_vkCmdDispatchGraphIndirectAMDX             vkCmdDispatchGraphIndirectAMDX             = 0;
-    PFN_vkCmdDispatchGraphIndirectCountAMDX        vkCmdDispatchGraphIndirectCountAMDX        = 0;
-#else
-    PFN_dummy vkCreateExecutionGraphPipelinesAMDX_placeholder               = 0;
-    PFN_dummy vkGetExecutionGraphPipelineScratchSizeAMDX_placeholder        = 0;
-    PFN_dummy vkGetExecutionGraphPipelineNodeIndexAMDX_placeholder          = 0;
-    PFN_dummy vkCmdInitializeGraphScratchMemoryAMDX_placeholder             = 0;
-    PFN_dummy vkCmdDispatchGraphAMDX_placeholder                            = 0;
-    PFN_dummy vkCmdDispatchGraphIndirectAMDX_placeholder                    = 0;
-    PFN_dummy vkCmdDispatchGraphIndirectCountAMDX_placeholder               = 0;
-#endif /*VK_ENABLE_BETA_EXTENSIONS*/
-
-    //=== VK_EXT_sample_locations ===
-    PFN_vkCmdSetSampleLocationsEXT                  vkCmdSetSampleLocationsEXT                  = 0;
-    PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT vkGetPhysicalDeviceMultisamplePropertiesEXT = 0;
-
-    //=== VK_KHR_get_memory_requirements2 ===
-    PFN_vkGetImageMemoryRequirements2KHR       vkGetImageMemoryRequirements2KHR       = 0;
-    PFN_vkGetBufferMemoryRequirements2KHR      vkGetBufferMemoryRequirements2KHR      = 0;
-    PFN_vkGetImageSparseMemoryRequirements2KHR vkGetImageSparseMemoryRequirements2KHR = 0;
-
-    //=== VK_KHR_acceleration_structure ===
-    PFN_vkCreateAccelerationStructureKHR                 vkCreateAccelerationStructureKHR                 = 0;
-    PFN_vkDestroyAccelerationStructureKHR                vkDestroyAccelerationStructureKHR                = 0;
-    PFN_vkCmdBuildAccelerationStructuresKHR              vkCmdBuildAccelerationStructuresKHR              = 0;
-    PFN_vkCmdBuildAccelerationStructuresIndirectKHR      vkCmdBuildAccelerationStructuresIndirectKHR      = 0;
-    PFN_vkBuildAccelerationStructuresKHR                 vkBuildAccelerationStructuresKHR                 = 0;
-    PFN_vkCopyAccelerationStructureKHR                   vkCopyAccelerationStructureKHR                   = 0;
-    PFN_vkCopyAccelerationStructureToMemoryKHR           vkCopyAccelerationStructureToMemoryKHR           = 0;
-    PFN_vkCopyMemoryToAccelerationStructureKHR           vkCopyMemoryToAccelerationStructureKHR           = 0;
-    PFN_vkWriteAccelerationStructuresPropertiesKHR       vkWriteAccelerationStructuresPropertiesKHR       = 0;
-    PFN_vkCmdCopyAccelerationStructureKHR                vkCmdCopyAccelerationStructureKHR                = 0;
-    PFN_vkCmdCopyAccelerationStructureToMemoryKHR        vkCmdCopyAccelerationStructureToMemoryKHR        = 0;
-    PFN_vkCmdCopyMemoryToAccelerationStructureKHR        vkCmdCopyMemoryToAccelerationStructureKHR        = 0;
-    PFN_vkGetAccelerationStructureDeviceAddressKHR       vkGetAccelerationStructureDeviceAddressKHR       = 0;
-    PFN_vkCmdWriteAccelerationStructuresPropertiesKHR    vkCmdWriteAccelerationStructuresPropertiesKHR    = 0;
-    PFN_vkGetDeviceAccelerationStructureCompatibilityKHR vkGetDeviceAccelerationStructureCompatibilityKHR = 0;
-    PFN_vkGetAccelerationStructureBuildSizesKHR          vkGetAccelerationStructureBuildSizesKHR          = 0;
-
-    //=== VK_KHR_ray_tracing_pipeline ===
-    PFN_vkCmdTraceRaysKHR                                 vkCmdTraceRaysKHR                                 = 0;
-    PFN_vkCreateRayTracingPipelinesKHR                    vkCreateRayTracingPipelinesKHR                    = 0;
-    PFN_vkGetRayTracingShaderGroupHandlesKHR              vkGetRayTracingShaderGroupHandlesKHR              = 0;
-    PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = 0;
-    PFN_vkCmdTraceRaysIndirectKHR                         vkCmdTraceRaysIndirectKHR                         = 0;
-    PFN_vkGetRayTracingShaderGroupStackSizeKHR            vkGetRayTracingShaderGroupStackSizeKHR            = 0;
-    PFN_vkCmdSetRayTracingPipelineStackSizeKHR            vkCmdSetRayTracingPipelineStackSizeKHR            = 0;
-
-    //=== VK_KHR_sampler_ycbcr_conversion ===
-    PFN_vkCreateSamplerYcbcrConversionKHR  vkCreateSamplerYcbcrConversionKHR  = 0;
-    PFN_vkDestroySamplerYcbcrConversionKHR vkDestroySamplerYcbcrConversionKHR = 0;
-
-    //=== VK_KHR_bind_memory2 ===
-    PFN_vkBindBufferMemory2KHR vkBindBufferMemory2KHR = 0;
-    PFN_vkBindImageMemory2KHR  vkBindImageMemory2KHR  = 0;
-
-    //=== VK_EXT_image_drm_format_modifier ===
-    PFN_vkGetImageDrmFormatModifierPropertiesEXT vkGetImageDrmFormatModifierPropertiesEXT = 0;
-
-    //=== VK_EXT_validation_cache ===
-    PFN_vkCreateValidationCacheEXT  vkCreateValidationCacheEXT  = 0;
-    PFN_vkDestroyValidationCacheEXT vkDestroyValidationCacheEXT = 0;
-    PFN_vkMergeValidationCachesEXT  vkMergeValidationCachesEXT  = 0;
-    PFN_vkGetValidationCacheDataEXT vkGetValidationCacheDataEXT = 0;
-
-    //=== VK_NV_shading_rate_image ===
-    PFN_vkCmdBindShadingRateImageNV          vkCmdBindShadingRateImageNV          = 0;
-    PFN_vkCmdSetViewportShadingRatePaletteNV vkCmdSetViewportShadingRatePaletteNV = 0;
-    PFN_vkCmdSetCoarseSampleOrderNV          vkCmdSetCoarseSampleOrderNV          = 0;
-
-    //=== VK_NV_ray_tracing ===
-    PFN_vkCreateAccelerationStructureNV                vkCreateAccelerationStructureNV                = 0;
-    PFN_vkDestroyAccelerationStructureNV               vkDestroyAccelerationStructureNV               = 0;
-    PFN_vkGetAccelerationStructureMemoryRequirementsNV vkGetAccelerationStructureMemoryRequirementsNV = 0;
-    PFN_vkBindAccelerationStructureMemoryNV            vkBindAccelerationStructureMemoryNV            = 0;
-    PFN_vkCmdBuildAccelerationStructureNV              vkCmdBuildAccelerationStructureNV              = 0;
-    PFN_vkCmdCopyAccelerationStructureNV               vkCmdCopyAccelerationStructureNV               = 0;
-    PFN_vkCmdTraceRaysNV                               vkCmdTraceRaysNV                               = 0;
-    PFN_vkCreateRayTracingPipelinesNV                  vkCreateRayTracingPipelinesNV                  = 0;
-    PFN_vkGetRayTracingShaderGroupHandlesNV            vkGetRayTracingShaderGroupHandlesNV            = 0;
-    PFN_vkGetAccelerationStructureHandleNV             vkGetAccelerationStructureHandleNV             = 0;
-    PFN_vkCmdWriteAccelerationStructuresPropertiesNV   vkCmdWriteAccelerationStructuresPropertiesNV   = 0;
-    PFN_vkCompileDeferredNV                            vkCompileDeferredNV                            = 0;
-
-    //=== VK_KHR_maintenance3 ===
-    PFN_vkGetDescriptorSetLayoutSupportKHR vkGetDescriptorSetLayoutSupportKHR = 0;
-
-    //=== VK_KHR_draw_indirect_count ===
-    PFN_vkCmdDrawIndirectCountKHR        vkCmdDrawIndirectCountKHR        = 0;
-    PFN_vkCmdDrawIndexedIndirectCountKHR vkCmdDrawIndexedIndirectCountKHR = 0;
-
-    //=== VK_EXT_external_memory_host ===
-    PFN_vkGetMemoryHostPointerPropertiesEXT vkGetMemoryHostPointerPropertiesEXT = 0;
-
-    //=== VK_AMD_buffer_marker ===
-    PFN_vkCmdWriteBufferMarkerAMD  vkCmdWriteBufferMarkerAMD  = 0;
-    PFN_vkCmdWriteBufferMarker2AMD vkCmdWriteBufferMarker2AMD = 0;
-
-    //=== VK_EXT_calibrated_timestamps ===
-    PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = 0;
-    PFN_vkGetCalibratedTimestampsEXT                   vkGetCalibratedTimestampsEXT                   = 0;
-
-    //=== VK_NV_mesh_shader ===
-    PFN_vkCmdDrawMeshTasksNV              vkCmdDrawMeshTasksNV              = 0;
-    PFN_vkCmdDrawMeshTasksIndirectNV      vkCmdDrawMeshTasksIndirectNV      = 0;
-    PFN_vkCmdDrawMeshTasksIndirectCountNV vkCmdDrawMeshTasksIndirectCountNV = 0;
-
-    //=== VK_NV_scissor_exclusive ===
-    PFN_vkCmdSetExclusiveScissorEnableNV vkCmdSetExclusiveScissorEnableNV = 0;
-    PFN_vkCmdSetExclusiveScissorNV       vkCmdSetExclusiveScissorNV       = 0;
-
-    //=== VK_NV_device_diagnostic_checkpoints ===
-    PFN_vkCmdSetCheckpointNV        vkCmdSetCheckpointNV        = 0;
-    PFN_vkGetQueueCheckpointDataNV  vkGetQueueCheckpointDataNV  = 0;
-    PFN_vkGetQueueCheckpointData2NV vkGetQueueCheckpointData2NV = 0;
-
-    //=== VK_KHR_timeline_semaphore ===
-    PFN_vkGetSemaphoreCounterValueKHR vkGetSemaphoreCounterValueKHR = 0;
-    PFN_vkWaitSemaphoresKHR           vkWaitSemaphoresKHR           = 0;
-    PFN_vkSignalSemaphoreKHR          vkSignalSemaphoreKHR          = 0;
-
-    //=== VK_INTEL_performance_query ===
-    PFN_vkInitializePerformanceApiINTEL         vkInitializePerformanceApiINTEL         = 0;
-    PFN_vkUninitializePerformanceApiINTEL       vkUninitializePerformanceApiINTEL       = 0;
-    PFN_vkCmdSetPerformanceMarkerINTEL          vkCmdSetPerformanceMarkerINTEL          = 0;
-    PFN_vkCmdSetPerformanceStreamMarkerINTEL    vkCmdSetPerformanceStreamMarkerINTEL    = 0;
-    PFN_vkCmdSetPerformanceOverrideINTEL        vkCmdSetPerformanceOverrideINTEL        = 0;
-    PFN_vkAcquirePerformanceConfigurationINTEL  vkAcquirePerformanceConfigurationINTEL  = 0;
-    PFN_vkReleasePerformanceConfigurationINTEL  vkReleasePerformanceConfigurationINTEL  = 0;
-    PFN_vkQueueSetPerformanceConfigurationINTEL vkQueueSetPerformanceConfigurationINTEL = 0;
-    PFN_vkGetPerformanceParameterINTEL          vkGetPerformanceParameterINTEL          = 0;
-
-    //=== VK_AMD_display_native_hdr ===
-    PFN_vkSetLocalDimmingAMD vkSetLocalDimmingAMD = 0;
-
-#if defined( VK_USE_PLATFORM_FUCHSIA )
-    //=== VK_FUCHSIA_imagepipe_surface ===
-    PFN_vkCreateImagePipeSurfaceFUCHSIA vkCreateImagePipeSurfaceFUCHSIA = 0;
-#else
-    PFN_dummy vkCreateImagePipeSurfaceFUCHSIA_placeholder                   = 0;
-#endif /*VK_USE_PLATFORM_FUCHSIA*/
-
-#if defined( VK_USE_PLATFORM_METAL_EXT )
-    //=== VK_EXT_metal_surface ===
-    PFN_vkCreateMetalSurfaceEXT vkCreateMetalSurfaceEXT = 0;
-#else
-    PFN_dummy vkCreateMetalSurfaceEXT_placeholder                           = 0;
-#endif /*VK_USE_PLATFORM_METAL_EXT*/
-
-    //=== VK_KHR_fragment_shading_rate ===
-    PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR vkGetPhysicalDeviceFragmentShadingRatesKHR = 0;
-    PFN_vkCmdSetFragmentShadingRateKHR             vkCmdSetFragmentShadingRateKHR             = 0;
-
-    //=== VK_KHR_dynamic_rendering_local_read ===
-    PFN_vkCmdSetRenderingAttachmentLocationsKHR    vkCmdSetRenderingAttachmentLocationsKHR    = 0;
-    PFN_vkCmdSetRenderingInputAttachmentIndicesKHR vkCmdSetRenderingInputAttachmentIndicesKHR = 0;
-
-    //=== VK_EXT_buffer_device_address ===
-    PFN_vkGetBufferDeviceAddressEXT vkGetBufferDeviceAddressEXT = 0;
-
-    //=== VK_EXT_tooling_info ===
-    PFN_vkGetPhysicalDeviceToolPropertiesEXT vkGetPhysicalDeviceToolPropertiesEXT = 0;
-
-    //=== VK_KHR_present_wait ===
-    PFN_vkWaitForPresentKHR vkWaitForPresentKHR = 0;
-
-    //=== VK_NV_cooperative_matrix ===
-    PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = 0;
-
-    //=== VK_NV_coverage_reduction_mode ===
-    PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = 0;
-
-#if defined( VK_USE_PLATFORM_WIN32_KHR )
-    //=== VK_EXT_full_screen_exclusive ===
-    PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT vkGetPhysicalDeviceSurfacePresentModes2EXT = 0;
-    PFN_vkAcquireFullScreenExclusiveModeEXT        vkAcquireFullScreenExclusiveModeEXT        = 0;
-    PFN_vkReleaseFullScreenExclusiveModeEXT        vkReleaseFullScreenExclusiveModeEXT        = 0;
-    PFN_vkGetDeviceGroupSurfacePresentModes2EXT    vkGetDeviceGroupSurfacePresentModes2EXT    = 0;
-#else
-    PFN_dummy vkGetPhysicalDeviceSurfacePresentModes2EXT_placeholder        = 0;
-    PFN_dummy vkAcquireFullScreenExclusiveModeEXT_placeholder               = 0;
-    PFN_dummy vkReleaseFullScreenExclusiveModeEXT_placeholder               = 0;
-    PFN_dummy vkGetDeviceGroupSurfacePresentModes2EXT_placeholder           = 0;
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-    //=== VK_EXT_headless_surface ===
-    PFN_vkCreateHeadlessSurfaceEXT vkCreateHeadlessSurfaceEXT = 0;
-
-    //=== VK_KHR_buffer_device_address ===
-    PFN_vkGetBufferDeviceAddressKHR              vkGetBufferDeviceAddressKHR              = 0;
-    PFN_vkGetBufferOpaqueCaptureAddressKHR       vkGetBufferOpaqueCaptureAddressKHR       = 0;
-    PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR vkGetDeviceMemoryOpaqueCaptureAddressKHR = 0;
-
-    //=== VK_EXT_line_rasterization ===
-    PFN_vkCmdSetLineStippleEXT vkCmdSetLineStippleEXT = 0;
-
-    //=== VK_EXT_host_query_reset ===
-    PFN_vkResetQueryPoolEXT vkResetQueryPoolEXT = 0;
-
-    //=== VK_EXT_extended_dynamic_state ===
-    PFN_vkCmdSetCullModeEXT              vkCmdSetCullModeEXT              = 0;
-    PFN_vkCmdSetFrontFaceEXT             vkCmdSetFrontFaceEXT             = 0;
-    PFN_vkCmdSetPrimitiveTopologyEXT     vkCmdSetPrimitiveTopologyEXT     = 0;
-    PFN_vkCmdSetViewportWithCountEXT     vkCmdSetViewportWithCountEXT     = 0;
-    PFN_vkCmdSetScissorWithCountEXT      vkCmdSetScissorWithCountEXT      = 0;
-    PFN_vkCmdBindVertexBuffers2EXT       vkCmdBindVertexBuffers2EXT       = 0;
-    PFN_vkCmdSetDepthTestEnableEXT       vkCmdSetDepthTestEnableEXT       = 0;
-    PFN_vkCmdSetDepthWriteEnableEXT      vkCmdSetDepthWriteEnableEXT      = 0;
-    PFN_vkCmdSetDepthCompareOpEXT        vkCmdSetDepthCompareOpEXT        = 0;
-    PFN_vkCmdSetDepthBoundsTestEnableEXT vkCmdSetDepthBoundsTestEnableEXT = 0;
-    PFN_vkCmdSetStencilTestEnableEXT     vkCmdSetStencilTestEnableEXT     = 0;
-    PFN_vkCmdSetStencilOpEXT             vkCmdSetStencilOpEXT             = 0;
-
-    //=== VK_KHR_deferred_host_operations ===
-    PFN_vkCreateDeferredOperationKHR            vkCreateDeferredOperationKHR            = 0;
-    PFN_vkDestroyDeferredOperationKHR           vkDestroyDeferredOperationKHR           = 0;
-    PFN_vkGetDeferredOperationMaxConcurrencyKHR vkGetDeferredOperationMaxConcurrencyKHR = 0;
-    PFN_vkGetDeferredOperationResultKHR         vkGetDeferredOperationResultKHR         = 0;
-    PFN_vkDeferredOperationJoinKHR              vkDeferredOperationJoinKHR              = 0;
-
-    //=== VK_KHR_pipeline_executable_properties ===
-    PFN_vkGetPipelineExecutablePropertiesKHR              vkGetPipelineExecutablePropertiesKHR              = 0;
-    PFN_vkGetPipelineExecutableStatisticsKHR              vkGetPipelineExecutableStatisticsKHR              = 0;
-    PFN_vkGetPipelineExecutableInternalRepresentationsKHR vkGetPipelineExecutableInternalRepresentationsKHR = 0;
-
-    //=== VK_EXT_host_image_copy ===
-    PFN_vkCopyMemoryToImageEXT          vkCopyMemoryToImageEXT          = 0;
-    PFN_vkCopyImageToMemoryEXT          vkCopyImageToMemoryEXT          = 0;
-    PFN_vkCopyImageToImageEXT           vkCopyImageToImageEXT           = 0;
-    PFN_vkTransitionImageLayoutEXT      vkTransitionImageLayoutEXT      = 0;
-    PFN_vkGetImageSubresourceLayout2EXT vkGetImageSubresourceLayout2EXT = 0;
-
-    //=== VK_KHR_map_memory2 ===
-    PFN_vkMapMemory2KHR   vkMapMemory2KHR   = 0;
-    PFN_vkUnmapMemory2KHR vkUnmapMemory2KHR = 0;
-
-    //=== VK_EXT_swapchain_maintenance1 ===
-    PFN_vkReleaseSwapchainImagesEXT vkReleaseSwapchainImagesEXT = 0;
-
-    //=== VK_NV_device_generated_commands ===
-    PFN_vkGetGeneratedCommandsMemoryRequirementsNV vkGetGeneratedCommandsMemoryRequirementsNV = 0;
-    PFN_vkCmdPreprocessGeneratedCommandsNV         vkCmdPreprocessGeneratedCommandsNV         = 0;
-    PFN_vkCmdExecuteGeneratedCommandsNV            vkCmdExecuteGeneratedCommandsNV            = 0;
-    PFN_vkCmdBindPipelineShaderGroupNV             vkCmdBindPipelineShaderGroupNV             = 0;
-    PFN_vkCreateIndirectCommandsLayoutNV           vkCreateIndirectCommandsLayoutNV           = 0;
-    PFN_vkDestroyIndirectCommandsLayoutNV          vkDestroyIndirectCommandsLayoutNV          = 0;
-
-    //=== VK_EXT_depth_bias_control ===
-    PFN_vkCmdSetDepthBias2EXT vkCmdSetDepthBias2EXT = 0;
-
-    //=== VK_EXT_acquire_drm_display ===
-    PFN_vkAcquireDrmDisplayEXT vkAcquireDrmDisplayEXT = 0;
-    PFN_vkGetDrmDisplayEXT     vkGetDrmDisplayEXT     = 0;
-
-    //=== VK_EXT_private_data ===
-    PFN_vkCreatePrivateDataSlotEXT  vkCreatePrivateDataSlotEXT  = 0;
-    PFN_vkDestroyPrivateDataSlotEXT vkDestroyPrivateDataSlotEXT = 0;
-    PFN_vkSetPrivateDataEXT         vkSetPrivateDataEXT         = 0;
-    PFN_vkGetPrivateDataEXT         vkGetPrivateDataEXT         = 0;
-
-    //=== VK_KHR_video_encode_queue ===
-    PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR = 0;
-    PFN_vkGetEncodedVideoSessionParametersKHR                   vkGetEncodedVideoSessionParametersKHR                   = 0;
-    PFN_vkCmdEncodeVideoKHR                                     vkCmdEncodeVideoKHR                                     = 0;
-
-#if defined( VK_ENABLE_BETA_EXTENSIONS )
-    //=== VK_NV_cuda_kernel_launch ===
-    PFN_vkCreateCudaModuleNV    vkCreateCudaModuleNV    = 0;
-    PFN_vkGetCudaModuleCacheNV  vkGetCudaModuleCacheNV  = 0;
-    PFN_vkCreateCudaFunctionNV  vkCreateCudaFunctionNV  = 0;
-    PFN_vkDestroyCudaModuleNV   vkDestroyCudaModuleNV   = 0;
-    PFN_vkDestroyCudaFunctionNV vkDestroyCudaFunctionNV = 0;
-    PFN_vkCmdCudaLaunchKernelNV vkCmdCudaLaunchKernelNV = 0;
-#else
-    PFN_dummy vkCreateCudaModuleNV_placeholder                              = 0;
-    PFN_dummy vkGetCudaModuleCacheNV_placeholder                            = 0;
-    PFN_dummy vkCreateCudaFunctionNV_placeholder                            = 0;
-    PFN_dummy vkDestroyCudaModuleNV_placeholder                             = 0;
-    PFN_dummy vkDestroyCudaFunctionNV_placeholder                           = 0;
-    PFN_dummy vkCmdCudaLaunchKernelNV_placeholder                           = 0;
-#endif /*VK_ENABLE_BETA_EXTENSIONS*/
-
-#if defined( VK_USE_PLATFORM_METAL_EXT )
-    //=== VK_EXT_metal_objects ===
-    PFN_vkExportMetalObjectsEXT vkExportMetalObjectsEXT = 0;
-#else
-    PFN_dummy vkExportMetalObjectsEXT_placeholder                           = 0;
-#endif /*VK_USE_PLATFORM_METAL_EXT*/
-
-    //=== VK_KHR_synchronization2 ===
-    PFN_vkCmdSetEvent2KHR        vkCmdSetEvent2KHR        = 0;
-    PFN_vkCmdResetEvent2KHR      vkCmdResetEvent2KHR      = 0;
-    PFN_vkCmdWaitEvents2KHR      vkCmdWaitEvents2KHR      = 0;
-    PFN_vkCmdPipelineBarrier2KHR vkCmdPipelineBarrier2KHR = 0;
-    PFN_vkCmdWriteTimestamp2KHR  vkCmdWriteTimestamp2KHR  = 0;
-    PFN_vkQueueSubmit2KHR        vkQueueSubmit2KHR        = 0;
-
-    //=== VK_EXT_descriptor_buffer ===
-    PFN_vkGetDescriptorSetLayoutSizeEXT                          vkGetDescriptorSetLayoutSizeEXT                          = 0;
-    PFN_vkGetDescriptorSetLayoutBindingOffsetEXT                 vkGetDescriptorSetLayoutBindingOffsetEXT                 = 0;
-    PFN_vkGetDescriptorEXT                                       vkGetDescriptorEXT                                       = 0;
-    PFN_vkCmdBindDescriptorBuffersEXT                            vkCmdBindDescriptorBuffersEXT                            = 0;
-    PFN_vkCmdSetDescriptorBufferOffsetsEXT                       vkCmdSetDescriptorBufferOffsetsEXT                       = 0;
-    PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT             vkCmdBindDescriptorBufferEmbeddedSamplersEXT             = 0;
-    PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT                vkGetBufferOpaqueCaptureDescriptorDataEXT                = 0;
-    PFN_vkGetImageOpaqueCaptureDescriptorDataEXT                 vkGetImageOpaqueCaptureDescriptorDataEXT                 = 0;
-    PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT             vkGetImageViewOpaqueCaptureDescriptorDataEXT             = 0;
-    PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT               vkGetSamplerOpaqueCaptureDescriptorDataEXT               = 0;
-    PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT = 0;
-
-    //=== VK_NV_fragment_shading_rate_enums ===
-    PFN_vkCmdSetFragmentShadingRateEnumNV vkCmdSetFragmentShadingRateEnumNV = 0;
-
-    //=== VK_EXT_mesh_shader ===
-    PFN_vkCmdDrawMeshTasksEXT              vkCmdDrawMeshTasksEXT              = 0;
-    PFN_vkCmdDrawMeshTasksIndirectEXT      vkCmdDrawMeshTasksIndirectEXT      = 0;
-    PFN_vkCmdDrawMeshTasksIndirectCountEXT vkCmdDrawMeshTasksIndirectCountEXT = 0;
-
-    //=== VK_KHR_copy_commands2 ===
-    PFN_vkCmdCopyBuffer2KHR        vkCmdCopyBuffer2KHR        = 0;
-    PFN_vkCmdCopyImage2KHR         vkCmdCopyImage2KHR         = 0;
-    PFN_vkCmdCopyBufferToImage2KHR vkCmdCopyBufferToImage2KHR = 0;
-    PFN_vkCmdCopyImageToBuffer2KHR vkCmdCopyImageToBuffer2KHR = 0;
-    PFN_vkCmdBlitImage2KHR         vkCmdBlitImage2KHR         = 0;
-    PFN_vkCmdResolveImage2KHR      vkCmdResolveImage2KHR      = 0;
-
-    //=== VK_EXT_device_fault ===
-    PFN_vkGetDeviceFaultInfoEXT vkGetDeviceFaultInfoEXT = 0;
-
-#if defined( VK_USE_PLATFORM_WIN32_KHR )
-    //=== VK_NV_acquire_winrt_display ===
-    PFN_vkAcquireWinrtDisplayNV vkAcquireWinrtDisplayNV = 0;
-    PFN_vkGetWinrtDisplayNV     vkGetWinrtDisplayNV     = 0;
-#else
-    PFN_dummy vkAcquireWinrtDisplayNV_placeholder                           = 0;
-    PFN_dummy vkGetWinrtDisplayNV_placeholder                               = 0;
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
-    //=== VK_EXT_directfb_surface ===
-    PFN_vkCreateDirectFBSurfaceEXT                        vkCreateDirectFBSurfaceEXT                        = 0;
-    PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT vkGetPhysicalDeviceDirectFBPresentationSupportEXT = 0;
-#else
-    PFN_dummy vkCreateDirectFBSurfaceEXT_placeholder                        = 0;
-    PFN_dummy vkGetPhysicalDeviceDirectFBPresentationSupportEXT_placeholder = 0;
-#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
-
-    //=== VK_EXT_vertex_input_dynamic_state ===
-    PFN_vkCmdSetVertexInputEXT vkCmdSetVertexInputEXT = 0;
-
-#if defined( VK_USE_PLATFORM_FUCHSIA )
-    //=== VK_FUCHSIA_external_memory ===
-    PFN_vkGetMemoryZirconHandleFUCHSIA           vkGetMemoryZirconHandleFUCHSIA           = 0;
-    PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA vkGetMemoryZirconHandlePropertiesFUCHSIA = 0;
-#else
-    PFN_dummy vkGetMemoryZirconHandleFUCHSIA_placeholder                    = 0;
-    PFN_dummy vkGetMemoryZirconHandlePropertiesFUCHSIA_placeholder          = 0;
-#endif /*VK_USE_PLATFORM_FUCHSIA*/
-
-#if defined( VK_USE_PLATFORM_FUCHSIA )
-    //=== VK_FUCHSIA_external_semaphore ===
-    PFN_vkImportSemaphoreZirconHandleFUCHSIA vkImportSemaphoreZirconHandleFUCHSIA = 0;
-    PFN_vkGetSemaphoreZirconHandleFUCHSIA    vkGetSemaphoreZirconHandleFUCHSIA    = 0;
-#else
-    PFN_dummy vkImportSemaphoreZirconHandleFUCHSIA_placeholder              = 0;
-    PFN_dummy vkGetSemaphoreZirconHandleFUCHSIA_placeholder                 = 0;
-#endif /*VK_USE_PLATFORM_FUCHSIA*/
-
-#if defined( VK_USE_PLATFORM_FUCHSIA )
-    //=== VK_FUCHSIA_buffer_collection ===
-    PFN_vkCreateBufferCollectionFUCHSIA               vkCreateBufferCollectionFUCHSIA               = 0;
-    PFN_vkSetBufferCollectionImageConstraintsFUCHSIA  vkSetBufferCollectionImageConstraintsFUCHSIA  = 0;
-    PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA vkSetBufferCollectionBufferConstraintsFUCHSIA = 0;
-    PFN_vkDestroyBufferCollectionFUCHSIA              vkDestroyBufferCollectionFUCHSIA              = 0;
-    PFN_vkGetBufferCollectionPropertiesFUCHSIA        vkGetBufferCollectionPropertiesFUCHSIA        = 0;
-#else
-    PFN_dummy vkCreateBufferCollectionFUCHSIA_placeholder                   = 0;
-    PFN_dummy vkSetBufferCollectionImageConstraintsFUCHSIA_placeholder      = 0;
-    PFN_dummy vkSetBufferCollectionBufferConstraintsFUCHSIA_placeholder     = 0;
-    PFN_dummy vkDestroyBufferCollectionFUCHSIA_placeholder                  = 0;
-    PFN_dummy vkGetBufferCollectionPropertiesFUCHSIA_placeholder            = 0;
-#endif /*VK_USE_PLATFORM_FUCHSIA*/
-
-    //=== VK_HUAWEI_subpass_shading ===
-    PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = 0;
-    PFN_vkCmdSubpassShadingHUAWEI                       vkCmdSubpassShadingHUAWEI                       = 0;
-
-    //=== VK_HUAWEI_invocation_mask ===
-    PFN_vkCmdBindInvocationMaskHUAWEI vkCmdBindInvocationMaskHUAWEI = 0;
-
-    //=== VK_NV_external_memory_rdma ===
-    PFN_vkGetMemoryRemoteAddressNV vkGetMemoryRemoteAddressNV = 0;
-
-    //=== VK_EXT_pipeline_properties ===
-    PFN_vkGetPipelinePropertiesEXT vkGetPipelinePropertiesEXT = 0;
-
-    //=== VK_EXT_extended_dynamic_state2 ===
-    PFN_vkCmdSetPatchControlPointsEXT      vkCmdSetPatchControlPointsEXT      = 0;
-    PFN_vkCmdSetRasterizerDiscardEnableEXT vkCmdSetRasterizerDiscardEnableEXT = 0;
-    PFN_vkCmdSetDepthBiasEnableEXT         vkCmdSetDepthBiasEnableEXT         = 0;
-    PFN_vkCmdSetLogicOpEXT                 vkCmdSetLogicOpEXT                 = 0;
-    PFN_vkCmdSetPrimitiveRestartEnableEXT  vkCmdSetPrimitiveRestartEnableEXT  = 0;
-
-#if defined( VK_USE_PLATFORM_SCREEN_QNX )
-    //=== VK_QNX_screen_surface ===
-    PFN_vkCreateScreenSurfaceQNX                        vkCreateScreenSurfaceQNX                        = 0;
-    PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX vkGetPhysicalDeviceScreenPresentationSupportQNX = 0;
-#else
-    PFN_dummy vkCreateScreenSurfaceQNX_placeholder                          = 0;
-    PFN_dummy vkGetPhysicalDeviceScreenPresentationSupportQNX_placeholder   = 0;
-#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
-
-    //=== VK_EXT_color_write_enable ===
-    PFN_vkCmdSetColorWriteEnableEXT vkCmdSetColorWriteEnableEXT = 0;
-
-    //=== VK_KHR_ray_tracing_maintenance1 ===
-    PFN_vkCmdTraceRaysIndirect2KHR vkCmdTraceRaysIndirect2KHR = 0;
-
-    //=== VK_EXT_multi_draw ===
-    PFN_vkCmdDrawMultiEXT        vkCmdDrawMultiEXT        = 0;
-    PFN_vkCmdDrawMultiIndexedEXT vkCmdDrawMultiIndexedEXT = 0;
-
-    //=== VK_EXT_opacity_micromap ===
-    PFN_vkCreateMicromapEXT                 vkCreateMicromapEXT                 = 0;
-    PFN_vkDestroyMicromapEXT                vkDestroyMicromapEXT                = 0;
-    PFN_vkCmdBuildMicromapsEXT              vkCmdBuildMicromapsEXT              = 0;
-    PFN_vkBuildMicromapsEXT                 vkBuildMicromapsEXT                 = 0;
-    PFN_vkCopyMicromapEXT                   vkCopyMicromapEXT                   = 0;
-    PFN_vkCopyMicromapToMemoryEXT           vkCopyMicromapToMemoryEXT           = 0;
-    PFN_vkCopyMemoryToMicromapEXT           vkCopyMemoryToMicromapEXT           = 0;
-    PFN_vkWriteMicromapsPropertiesEXT       vkWriteMicromapsPropertiesEXT       = 0;
-    PFN_vkCmdCopyMicromapEXT                vkCmdCopyMicromapEXT                = 0;
-    PFN_vkCmdCopyMicromapToMemoryEXT        vkCmdCopyMicromapToMemoryEXT        = 0;
-    PFN_vkCmdCopyMemoryToMicromapEXT        vkCmdCopyMemoryToMicromapEXT        = 0;
-    PFN_vkCmdWriteMicromapsPropertiesEXT    vkCmdWriteMicromapsPropertiesEXT    = 0;
-    PFN_vkGetDeviceMicromapCompatibilityEXT vkGetDeviceMicromapCompatibilityEXT = 0;
-    PFN_vkGetMicromapBuildSizesEXT          vkGetMicromapBuildSizesEXT          = 0;
-
-    //=== VK_HUAWEI_cluster_culling_shader ===
-    PFN_vkCmdDrawClusterHUAWEI         vkCmdDrawClusterHUAWEI         = 0;
-    PFN_vkCmdDrawClusterIndirectHUAWEI vkCmdDrawClusterIndirectHUAWEI = 0;
-
-    //=== VK_EXT_pageable_device_local_memory ===
-    PFN_vkSetDeviceMemoryPriorityEXT vkSetDeviceMemoryPriorityEXT = 0;
-
-    //=== VK_KHR_maintenance4 ===
-    PFN_vkGetDeviceBufferMemoryRequirementsKHR      vkGetDeviceBufferMemoryRequirementsKHR      = 0;
-    PFN_vkGetDeviceImageMemoryRequirementsKHR       vkGetDeviceImageMemoryRequirementsKHR       = 0;
-    PFN_vkGetDeviceImageSparseMemoryRequirementsKHR vkGetDeviceImageSparseMemoryRequirementsKHR = 0;
-
-    //=== VK_VALVE_descriptor_set_host_mapping ===
-    PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE vkGetDescriptorSetLayoutHostMappingInfoVALVE = 0;
-    PFN_vkGetDescriptorSetHostMappingVALVE           vkGetDescriptorSetHostMappingVALVE           = 0;
-
-    //=== VK_NV_copy_memory_indirect ===
-    PFN_vkCmdCopyMemoryIndirectNV        vkCmdCopyMemoryIndirectNV        = 0;
-    PFN_vkCmdCopyMemoryToImageIndirectNV vkCmdCopyMemoryToImageIndirectNV = 0;
-
-    //=== VK_NV_memory_decompression ===
-    PFN_vkCmdDecompressMemoryNV              vkCmdDecompressMemoryNV              = 0;
-    PFN_vkCmdDecompressMemoryIndirectCountNV vkCmdDecompressMemoryIndirectCountNV = 0;
-
-    //=== VK_NV_device_generated_commands_compute ===
-    PFN_vkGetPipelineIndirectMemoryRequirementsNV vkGetPipelineIndirectMemoryRequirementsNV = 0;
-    PFN_vkCmdUpdatePipelineIndirectBufferNV       vkCmdUpdatePipelineIndirectBufferNV       = 0;
-    PFN_vkGetPipelineIndirectDeviceAddressNV      vkGetPipelineIndirectDeviceAddressNV      = 0;
-
-    //=== VK_EXT_extended_dynamic_state3 ===
-    PFN_vkCmdSetDepthClampEnableEXT                 vkCmdSetDepthClampEnableEXT                 = 0;
-    PFN_vkCmdSetPolygonModeEXT                      vkCmdSetPolygonModeEXT                      = 0;
-    PFN_vkCmdSetRasterizationSamplesEXT             vkCmdSetRasterizationSamplesEXT             = 0;
-    PFN_vkCmdSetSampleMaskEXT                       vkCmdSetSampleMaskEXT                       = 0;
-    PFN_vkCmdSetAlphaToCoverageEnableEXT            vkCmdSetAlphaToCoverageEnableEXT            = 0;
-    PFN_vkCmdSetAlphaToOneEnableEXT                 vkCmdSetAlphaToOneEnableEXT                 = 0;
-    PFN_vkCmdSetLogicOpEnableEXT                    vkCmdSetLogicOpEnableEXT                    = 0;
-    PFN_vkCmdSetColorBlendEnableEXT                 vkCmdSetColorBlendEnableEXT                 = 0;
-    PFN_vkCmdSetColorBlendEquationEXT               vkCmdSetColorBlendEquationEXT               = 0;
-    PFN_vkCmdSetColorWriteMaskEXT                   vkCmdSetColorWriteMaskEXT                   = 0;
-    PFN_vkCmdSetTessellationDomainOriginEXT         vkCmdSetTessellationDomainOriginEXT         = 0;
-    PFN_vkCmdSetRasterizationStreamEXT              vkCmdSetRasterizationStreamEXT              = 0;
-    PFN_vkCmdSetConservativeRasterizationModeEXT    vkCmdSetConservativeRasterizationModeEXT    = 0;
-    PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT vkCmdSetExtraPrimitiveOverestimationSizeEXT = 0;
-    PFN_vkCmdSetDepthClipEnableEXT                  vkCmdSetDepthClipEnableEXT                  = 0;
-    PFN_vkCmdSetSampleLocationsEnableEXT            vkCmdSetSampleLocationsEnableEXT            = 0;
-    PFN_vkCmdSetColorBlendAdvancedEXT               vkCmdSetColorBlendAdvancedEXT               = 0;
-    PFN_vkCmdSetProvokingVertexModeEXT              vkCmdSetProvokingVertexModeEXT              = 0;
-    PFN_vkCmdSetLineRasterizationModeEXT            vkCmdSetLineRasterizationModeEXT            = 0;
-    PFN_vkCmdSetLineStippleEnableEXT                vkCmdSetLineStippleEnableEXT                = 0;
-    PFN_vkCmdSetDepthClipNegativeOneToOneEXT        vkCmdSetDepthClipNegativeOneToOneEXT        = 0;
-    PFN_vkCmdSetViewportWScalingEnableNV            vkCmdSetViewportWScalingEnableNV            = 0;
-    PFN_vkCmdSetViewportSwizzleNV                   vkCmdSetViewportSwizzleNV                   = 0;
-    PFN_vkCmdSetCoverageToColorEnableNV             vkCmdSetCoverageToColorEnableNV             = 0;
-    PFN_vkCmdSetCoverageToColorLocationNV           vkCmdSetCoverageToColorLocationNV           = 0;
-    PFN_vkCmdSetCoverageModulationModeNV            vkCmdSetCoverageModulationModeNV            = 0;
-    PFN_vkCmdSetCoverageModulationTableEnableNV     vkCmdSetCoverageModulationTableEnableNV     = 0;
-    PFN_vkCmdSetCoverageModulationTableNV           vkCmdSetCoverageModulationTableNV           = 0;
-    PFN_vkCmdSetShadingRateImageEnableNV            vkCmdSetShadingRateImageEnableNV            = 0;
-    PFN_vkCmdSetRepresentativeFragmentTestEnableNV  vkCmdSetRepresentativeFragmentTestEnableNV  = 0;
-    PFN_vkCmdSetCoverageReductionModeNV             vkCmdSetCoverageReductionModeNV             = 0;
-
-    //=== VK_EXT_shader_module_identifier ===
-    PFN_vkGetShaderModuleIdentifierEXT           vkGetShaderModuleIdentifierEXT           = 0;
-    PFN_vkGetShaderModuleCreateInfoIdentifierEXT vkGetShaderModuleCreateInfoIdentifierEXT = 0;
-
-    //=== VK_NV_optical_flow ===
-    PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV vkGetPhysicalDeviceOpticalFlowImageFormatsNV = 0;
-    PFN_vkCreateOpticalFlowSessionNV                 vkCreateOpticalFlowSessionNV                 = 0;
-    PFN_vkDestroyOpticalFlowSessionNV                vkDestroyOpticalFlowSessionNV                = 0;
-    PFN_vkBindOpticalFlowSessionImageNV              vkBindOpticalFlowSessionImageNV              = 0;
-    PFN_vkCmdOpticalFlowExecuteNV                    vkCmdOpticalFlowExecuteNV                    = 0;
-
-    //=== VK_KHR_maintenance5 ===
-    PFN_vkCmdBindIndexBuffer2KHR             vkCmdBindIndexBuffer2KHR             = 0;
-    PFN_vkGetRenderingAreaGranularityKHR     vkGetRenderingAreaGranularityKHR     = 0;
-    PFN_vkGetDeviceImageSubresourceLayoutKHR vkGetDeviceImageSubresourceLayoutKHR = 0;
-    PFN_vkGetImageSubresourceLayout2KHR      vkGetImageSubresourceLayout2KHR      = 0;
-
-    //=== VK_AMD_anti_lag ===
-    PFN_vkAntiLagUpdateAMD vkAntiLagUpdateAMD = 0;
-
-    //=== VK_EXT_shader_object ===
-    PFN_vkCreateShadersEXT         vkCreateShadersEXT         = 0;
-    PFN_vkDestroyShaderEXT         vkDestroyShaderEXT         = 0;
-    PFN_vkGetShaderBinaryDataEXT   vkGetShaderBinaryDataEXT   = 0;
-    PFN_vkCmdBindShadersEXT        vkCmdBindShadersEXT        = 0;
-    PFN_vkCmdSetDepthClampRangeEXT vkCmdSetDepthClampRangeEXT = 0;
-
-    //=== VK_KHR_pipeline_binary ===
-    PFN_vkCreatePipelineBinariesKHR      vkCreatePipelineBinariesKHR      = 0;
-    PFN_vkDestroyPipelineBinaryKHR       vkDestroyPipelineBinaryKHR       = 0;
-    PFN_vkGetPipelineKeyKHR              vkGetPipelineKeyKHR              = 0;
-    PFN_vkGetPipelineBinaryDataKHR       vkGetPipelineBinaryDataKHR       = 0;
-    PFN_vkReleaseCapturedPipelineDataKHR vkReleaseCapturedPipelineDataKHR = 0;
-
-    //=== VK_QCOM_tile_properties ===
-    PFN_vkGetFramebufferTilePropertiesQCOM      vkGetFramebufferTilePropertiesQCOM      = 0;
-    PFN_vkGetDynamicRenderingTilePropertiesQCOM vkGetDynamicRenderingTilePropertiesQCOM = 0;
-
-    //=== VK_NV_low_latency2 ===
-    PFN_vkSetLatencySleepModeNV  vkSetLatencySleepModeNV  = 0;
-    PFN_vkLatencySleepNV         vkLatencySleepNV         = 0;
-    PFN_vkSetLatencyMarkerNV     vkSetLatencyMarkerNV     = 0;
-    PFN_vkGetLatencyTimingsNV    vkGetLatencyTimingsNV    = 0;
-    PFN_vkQueueNotifyOutOfBandNV vkQueueNotifyOutOfBandNV = 0;
-
-    //=== VK_KHR_cooperative_matrix ===
-    PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR = 0;
-
-    //=== VK_EXT_attachment_feedback_loop_dynamic_state ===
-    PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT vkCmdSetAttachmentFeedbackLoopEnableEXT = 0;
-
-#if defined( VK_USE_PLATFORM_SCREEN_QNX )
-    //=== VK_QNX_external_memory_screen_buffer ===
-    PFN_vkGetScreenBufferPropertiesQNX vkGetScreenBufferPropertiesQNX = 0;
-#else
-    PFN_dummy vkGetScreenBufferPropertiesQNX_placeholder                    = 0;
-#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
-
-    //=== VK_KHR_line_rasterization ===
-    PFN_vkCmdSetLineStippleKHR vkCmdSetLineStippleKHR = 0;
-
-    //=== VK_KHR_calibrated_timestamps ===
-    PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR vkGetPhysicalDeviceCalibrateableTimeDomainsKHR = 0;
-    PFN_vkGetCalibratedTimestampsKHR                   vkGetCalibratedTimestampsKHR                   = 0;