[vulkan] Add FUCHSIAX header definitions for BufferCollection.

- Fixed clang-format host/arch bug in rebuild.sh.

Bug: 73450

Change-Id: I80ae8d36f7c245eaeac9659913c0bf873a0ad477
Reviewed-on: https://fuchsia-review.googlesource.com/c/third_party/Vulkan-Headers/+/531803
Reviewed-by: John Bauman <jbauman@google.com>
diff --git a/include/vulkan/vulkan.hpp b/include/vulkan/vulkan.hpp
index 750982f..759f591 100644
--- a/include/vulkan/vulkan.hpp
+++ b/include/vulkan/vulkan.hpp
@@ -1216,69 +1216,142 @@
 #if !defined(VK_NO_PROTOTYPES)
 class DispatchLoaderStatic {
 public:
-#if defined(VK_USE_PLATFORM_WIN32_KHR)
-  VkResult vkAcquireFullScreenExclusiveModeEXT(
-      VkDevice device, VkSwapchainKHR swapchain) const VULKAN_HPP_NOEXCEPT {
-    return ::vkAcquireFullScreenExclusiveModeEXT(device, swapchain);
-  }
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+  //=== VK_VERSION_1_0 ===
 
-  VkResult
-  vkAcquireNextImage2KHR(VkDevice device,
-                         const VkAcquireNextImageInfoKHR *pAcquireInfo,
-                         uint32_t *pImageIndex) const VULKAN_HPP_NOEXCEPT {
-    return ::vkAcquireNextImage2KHR(device, pAcquireInfo, pImageIndex);
+  VkResult vkCreateInstance(const VkInstanceCreateInfo *pCreateInfo,
+                            const VkAllocationCallbacks *pAllocator,
+                            VkInstance *pInstance) const VULKAN_HPP_NOEXCEPT {
+    return ::vkCreateInstance(pCreateInfo, pAllocator, pInstance);
   }
 
-  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 vkAcquirePerformanceConfigurationINTEL(
-      VkDevice device,
-      const VkPerformanceConfigurationAcquireInfoINTEL *pAcquireInfo,
-      VkPerformanceConfigurationINTEL *pConfiguration) const
+  void vkDestroyInstance(VkInstance instance,
+                         const VkAllocationCallbacks *pAllocator) const
       VULKAN_HPP_NOEXCEPT {
-    return ::vkAcquirePerformanceConfigurationINTEL(device, pAcquireInfo,
-                                                    pConfiguration);
+    return ::vkDestroyInstance(instance, pAllocator);
   }
 
-  VkResult vkAcquireProfilingLockKHR(
-      VkDevice device,
-      const VkAcquireProfilingLockInfoKHR *pInfo) const VULKAN_HPP_NOEXCEPT {
-    return ::vkAcquireProfilingLockKHR(device, pInfo);
+  VkResult vkEnumeratePhysicalDevices(
+      VkInstance instance, uint32_t *pPhysicalDeviceCount,
+      VkPhysicalDevice *pPhysicalDevices) const VULKAN_HPP_NOEXCEPT {
+    return ::vkEnumeratePhysicalDevices(instance, pPhysicalDeviceCount,
+                                        pPhysicalDevices);
   }
 
-#if defined(VK_USE_PLATFORM_WIN32_KHR)
-  VkResult
-  vkAcquireWinrtDisplayNV(VkPhysicalDevice physicalDevice,
-                          VkDisplayKHR display) const VULKAN_HPP_NOEXCEPT {
-    return ::vkAcquireWinrtDisplayNV(physicalDevice, display);
-  }
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#if defined(VK_USE_PLATFORM_XLIB_XRANDR_EXT)
-  VkResult
-  vkAcquireXlibDisplayEXT(VkPhysicalDevice physicalDevice, Display *dpy,
-                          VkDisplayKHR display) const VULKAN_HPP_NOEXCEPT {
-    return ::vkAcquireXlibDisplayEXT(physicalDevice, dpy, display);
-  }
-#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
-
-  VkResult vkAllocateCommandBuffers(
-      VkDevice device, const VkCommandBufferAllocateInfo *pAllocateInfo,
-      VkCommandBuffer *pCommandBuffers) const VULKAN_HPP_NOEXCEPT {
-    return ::vkAllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers);
+  void vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice,
+                                   VkPhysicalDeviceFeatures *pFeatures) const
+      VULKAN_HPP_NOEXCEPT {
+    return ::vkGetPhysicalDeviceFeatures(physicalDevice, pFeatures);
   }
 
-  VkResult vkAllocateDescriptorSets(
-      VkDevice device, const VkDescriptorSetAllocateInfo *pAllocateInfo,
-      VkDescriptorSet *pDescriptorSets) const VULKAN_HPP_NOEXCEPT {
-    return ::vkAllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets);
+  void vkGetPhysicalDeviceFormatProperties(
+      VkPhysicalDevice physicalDevice, VkFormat format,
+      VkFormatProperties *pFormatProperties) const VULKAN_HPP_NOEXCEPT {
+    return ::vkGetPhysicalDeviceFormatProperties(physicalDevice, format,
+                                                 pFormatProperties);
+  }
+
+  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 vkGetPhysicalDeviceProperties(
+      VkPhysicalDevice physicalDevice,
+      VkPhysicalDeviceProperties *pProperties) const VULKAN_HPP_NOEXCEPT {
+    return ::vkGetPhysicalDeviceProperties(physicalDevice, pProperties);
+  }
+
+  void vkGetPhysicalDeviceQueueFamilyProperties(
+      VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount,
+      VkQueueFamilyProperties *pQueueFamilyProperties) const
+      VULKAN_HPP_NOEXCEPT {
+    return ::vkGetPhysicalDeviceQueueFamilyProperties(
+        physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
+  }
+
+  void vkGetPhysicalDeviceMemoryProperties(
+      VkPhysicalDevice physicalDevice,
+      VkPhysicalDeviceMemoryProperties *pMemoryProperties) const
+      VULKAN_HPP_NOEXCEPT {
+    return ::vkGetPhysicalDeviceMemoryProperties(physicalDevice,
+                                                 pMemoryProperties);
+  }
+
+  PFN_vkVoidFunction
+  vkGetInstanceProcAddr(VkInstance instance,
+                        const char *pName) const VULKAN_HPP_NOEXCEPT {
+    return ::vkGetInstanceProcAddr(instance, pName);
+  }
+
+  PFN_vkVoidFunction
+  vkGetDeviceProcAddr(VkDevice device,
+                      const char *pName) const VULKAN_HPP_NOEXCEPT {
+    return ::vkGetDeviceProcAddr(device, pName);
+  }
+
+  VkResult vkCreateDevice(VkPhysicalDevice physicalDevice,
+                          const VkDeviceCreateInfo *pCreateInfo,
+                          const VkAllocationCallbacks *pAllocator,
+                          VkDevice *pDevice) const VULKAN_HPP_NOEXCEPT {
+    return ::vkCreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice);
+  }
+
+  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 ::vkEnumerateDeviceExtensionProperties(physicalDevice, pLayerName,
+                                                  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);
+  }
+
+  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 vkQueueWaitIdle(VkQueue queue) const VULKAN_HPP_NOEXCEPT {
+    return ::vkQueueWaitIdle(queue);
+  }
+
+  VkResult vkDeviceWaitIdle(VkDevice device) const VULKAN_HPP_NOEXCEPT {
+    return ::vkDeviceWaitIdle(device);
   }
 
   VkResult vkAllocateMemory(VkDevice device,
@@ -1288,18 +1361,42 @@
     return ::vkAllocateMemory(device, pAllocateInfo, pAllocator, pMemory);
   }
 
-  VkResult vkBeginCommandBuffer(
-      VkCommandBuffer commandBuffer,
-      const VkCommandBufferBeginInfo *pBeginInfo) const VULKAN_HPP_NOEXCEPT {
-    return ::vkBeginCommandBuffer(commandBuffer, pBeginInfo);
+  void vkFreeMemory(VkDevice device, VkDeviceMemory memory,
+                    const VkAllocationCallbacks *pAllocator) const
+      VULKAN_HPP_NOEXCEPT {
+    return ::vkFreeMemory(device, memory, pAllocator);
   }
 
-  VkResult vkBindAccelerationStructureMemoryNV(
-      VkDevice device, uint32_t bindInfoCount,
-      const VkBindAccelerationStructureMemoryInfoNV *pBindInfos) const
+  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);
+  }
+
+  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);
+  }
+
+  void vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory,
+                                   VkDeviceSize *pCommittedMemoryInBytes) const
       VULKAN_HPP_NOEXCEPT {
-    return ::vkBindAccelerationStructureMemoryNV(device, bindInfoCount,
-                                                 pBindInfos);
+    return ::vkGetDeviceMemoryCommitment(device, memory,
+                                         pCommittedMemoryInBytes);
   }
 
   VkResult
@@ -1308,104 +1405,493 @@
     return ::vkBindBufferMemory(device, buffer, memory, memoryOffset);
   }
 
-  VkResult vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount,
-                               const VkBindBufferMemoryInfo *pBindInfos) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkBindBufferMemory2(device, bindInfoCount, pBindInfos);
-  }
-
-  VkResult vkBindBufferMemory2KHR(
-      VkDevice device, uint32_t bindInfoCount,
-      const VkBindBufferMemoryInfo *pBindInfos) const VULKAN_HPP_NOEXCEPT {
-    return ::vkBindBufferMemory2KHR(device, bindInfoCount, pBindInfos);
-  }
-
   VkResult
   vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory,
                     VkDeviceSize memoryOffset) const VULKAN_HPP_NOEXCEPT {
     return ::vkBindImageMemory(device, image, memory, memoryOffset);
   }
 
-  VkResult vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount,
-                              const VkBindImageMemoryInfo *pBindInfos) const
+  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 vkGetImageSparseMemoryRequirements(
+      VkDevice device, VkImage image, uint32_t *pSparseMemoryRequirementCount,
+      VkSparseImageMemoryRequirements *pSparseMemoryRequirements) const
       VULKAN_HPP_NOEXCEPT {
-    return ::vkBindImageMemory2(device, bindInfoCount, pBindInfos);
+    return ::vkGetImageSparseMemoryRequirements(device, image,
+                                                pSparseMemoryRequirementCount,
+                                                pSparseMemoryRequirements);
   }
 
-  VkResult vkBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount,
-                                 const VkBindImageMemoryInfo *pBindInfos) const
+  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 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 ::vkBindImageMemory2KHR(device, bindInfoCount, pBindInfos);
+    return ::vkDestroyFence(device, fence, pAllocator);
   }
 
-  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 vkResetFences(VkDevice device, uint32_t fenceCount,
+                         const VkFence *pFences) const VULKAN_HPP_NOEXCEPT {
+    return ::vkResetFences(device, fenceCount, pFences);
   }
 
-  void vkCmdBeginConditionalRenderingEXT(
+  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,
+                           const VkAllocationCallbacks *pAllocator,
+                           VkSampler *pSampler) const VULKAN_HPP_NOEXCEPT {
+    return ::vkCreateSampler(device, pCreateInfo, pAllocator, pSampler);
+  }
+
+  void vkDestroySampler(VkDevice device, VkSampler sampler,
+                        const VkAllocationCallbacks *pAllocator) const
+      VULKAN_HPP_NOEXCEPT {
+    return ::vkDestroySampler(device, sampler, pAllocator);
+  }
+
+  VkResult vkCreateDescriptorSetLayout(
+      VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo,
+      const VkAllocationCallbacks *pAllocator,
+      VkDescriptorSetLayout *pSetLayout) const VULKAN_HPP_NOEXCEPT {
+    return ::vkCreateDescriptorSetLayout(device, pCreateInfo, pAllocator,
+                                         pSetLayout);
+  }
+
+  void vkDestroyDescriptorSetLayout(
+      VkDevice device, VkDescriptorSetLayout descriptorSetLayout,
+      const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT {
+    return ::vkDestroyDescriptorSetLayout(device, descriptorSetLayout,
+                                          pAllocator);
+  }
+
+  VkResult vkCreateDescriptorPool(
+      VkDevice device, const VkDescriptorPoolCreateInfo *pCreateInfo,
+      const VkAllocationCallbacks *pAllocator,
+      VkDescriptorPool *pDescriptorPool) const VULKAN_HPP_NOEXCEPT {
+    return ::vkCreateDescriptorPool(device, pCreateInfo, pAllocator,
+                                    pDescriptorPool);
+  }
+
+  void vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
+                               const VkAllocationCallbacks *pAllocator) const
+      VULKAN_HPP_NOEXCEPT {
+    return ::vkDestroyDescriptorPool(device, descriptorPool, pAllocator);
+  }
+
+  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 VkConditionalRenderingBeginInfoEXT *pConditionalRenderingBegin)
-      const VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdBeginConditionalRenderingEXT(commandBuffer,
-                                               pConditionalRenderingBegin);
+      const VkCommandBufferBeginInfo *pBeginInfo) const VULKAN_HPP_NOEXCEPT {
+    return ::vkBeginCommandBuffer(commandBuffer, pBeginInfo);
   }
 
-  void vkCmdBeginDebugUtilsLabelEXT(
-      VkCommandBuffer commandBuffer,
-      const VkDebugUtilsLabelEXT *pLabelInfo) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdBeginDebugUtilsLabelEXT(commandBuffer, pLabelInfo);
+  VkResult
+  vkEndCommandBuffer(VkCommandBuffer commandBuffer) const VULKAN_HPP_NOEXCEPT {
+    return ::vkEndCommandBuffer(commandBuffer);
   }
 
-  void vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
-                       uint32_t query,
-                       VkQueryControlFlags flags) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdBeginQuery(commandBuffer, queryPool, query, flags);
+  VkResult vkResetCommandBuffer(VkCommandBuffer commandBuffer,
+                                VkCommandBufferResetFlags flags) const
+      VULKAN_HPP_NOEXCEPT {
+    return ::vkResetCommandBuffer(commandBuffer, flags);
   }
 
-  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 vkCmdBindPipeline(VkCommandBuffer commandBuffer,
+                         VkPipelineBindPoint pipelineBindPoint,
+                         VkPipeline pipeline) const VULKAN_HPP_NOEXCEPT {
+    return ::vkCmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
   }
 
   void
-  vkCmdBeginRenderPass(VkCommandBuffer commandBuffer,
-                       const VkRenderPassBeginInfo *pRenderPassBegin,
-                       VkSubpassContents contents) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents);
+  vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport,
+                   uint32_t viewportCount,
+                   const VkViewport *pViewports) const VULKAN_HPP_NOEXCEPT {
+    return ::vkCmdSetViewport(commandBuffer, firstViewport, viewportCount,
+                              pViewports);
   }
 
-  void vkCmdBeginRenderPass2(VkCommandBuffer commandBuffer,
-                             const VkRenderPassBeginInfo *pRenderPassBegin,
-                             const VkSubpassBeginInfo *pSubpassBeginInfo) const
+  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 ::vkCmdBeginRenderPass2(commandBuffer, pRenderPassBegin,
-                                   pSubpassBeginInfo);
+    return ::vkCmdSetBlendConstants(commandBuffer, blendConstants);
   }
 
-  void vkCmdBeginRenderPass2KHR(
-      VkCommandBuffer commandBuffer,
-      const VkRenderPassBeginInfo *pRenderPassBegin,
-      const VkSubpassBeginInfo *pSubpassBeginInfo) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdBeginRenderPass2KHR(commandBuffer, pRenderPassBegin,
-                                      pSubpassBeginInfo);
+  void vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds,
+                           float maxDepthBounds) const VULKAN_HPP_NOEXCEPT {
+    return ::vkCmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds);
   }
 
-  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
+  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(
@@ -1424,34 +1910,6 @@
     return ::vkCmdBindIndexBuffer(commandBuffer, buffer, offset, indexType);
   }
 
-  void vkCmdBindPipeline(VkCommandBuffer commandBuffer,
-                         VkPipelineBindPoint pipelineBindPoint,
-                         VkPipeline pipeline) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
-  }
-
-  void vkCmdBindPipelineShaderGroupNV(
-      VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint,
-      VkPipeline pipeline, uint32_t groupIndex) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdBindPipelineShaderGroupNV(commandBuffer, pipelineBindPoint,
-                                            pipeline, groupIndex);
-  }
-
-  void vkCmdBindShadingRateImageNV(
-      VkCommandBuffer commandBuffer, VkImageView imageView,
-      VkImageLayout imageLayout) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdBindShadingRateImageNV(commandBuffer, imageView, imageLayout);
-  }
-
-  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 vkCmdBindVertexBuffers(
       VkCommandBuffer commandBuffer, uint32_t firstBinding,
       uint32_t bindingCount, const VkBuffer *pBuffers,
@@ -1460,14 +1918,60 @@
                                     pBuffers, pOffsets);
   }
 
-  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 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 vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX,
+                     uint32_t groupCountY,
+                     uint32_t groupCountZ) const VULKAN_HPP_NOEXCEPT {
+    return ::vkCmdDispatch(commandBuffer, groupCountX, groupCountY,
+                           groupCountZ);
+  }
+
+  void vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
+                             VkDeviceSize offset) const VULKAN_HPP_NOEXCEPT {
+    return ::vkCmdDispatchIndirect(commandBuffer, buffer, offset);
+  }
+
+  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 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 vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage,
@@ -1479,49 +1983,33 @@
                             dstImageLayout, regionCount, pRegions, filter);
   }
 
-  void vkCmdBlitImage2KHR(VkCommandBuffer commandBuffer,
-                          const VkBlitImageInfo2KHR *pBlitImageInfo) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdBlitImage2KHR(commandBuffer, pBlitImageInfo);
+  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 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 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 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);
+  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 vkCmdBuildAccelerationStructuresKHR(
-      VkCommandBuffer commandBuffer, uint32_t infoCount,
-      const VkAccelerationStructureBuildGeometryInfoKHR *pInfos,
-      const VkAccelerationStructureBuildRangeInfoKHR *const *ppBuildRangeInfos)
-      const VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdBuildAccelerationStructuresKHR(commandBuffer, infoCount,
-                                                 pInfos, ppBuildRangeInfos);
-  }
-
-  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 vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer,
+                       VkDeviceSize dstOffset, VkDeviceSize size,
+                       uint32_t data) const VULKAN_HPP_NOEXCEPT {
+    return ::vkCmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
   }
 
   void vkCmdClearColorImage(
@@ -1540,357 +2028,50 @@
                                          pDepthStencil, rangeCount, pRanges);
   }
 
-  void vkCmdCopyAccelerationStructureKHR(
-      VkCommandBuffer commandBuffer,
-      const VkCopyAccelerationStructureInfoKHR *pInfo) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdCopyAccelerationStructureKHR(commandBuffer, pInfo);
-  }
-
-  void vkCmdCopyAccelerationStructureNV(
-      VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst,
-      VkAccelerationStructureNV src,
-      VkCopyAccelerationStructureModeKHR mode) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdCopyAccelerationStructureNV(commandBuffer, dst, src, mode);
-  }
-
-  void vkCmdCopyAccelerationStructureToMemoryKHR(
-      VkCommandBuffer commandBuffer,
-      const VkCopyAccelerationStructureToMemoryInfoKHR *pInfo) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdCopyAccelerationStructureToMemoryKHR(commandBuffer, pInfo);
-  }
-
-  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 vkCmdCopyBuffer2KHR(VkCommandBuffer commandBuffer,
-                           const VkCopyBufferInfo2KHR *pCopyBufferInfo) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdCopyBuffer2KHR(commandBuffer, pCopyBufferInfo);
-  }
-
-  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 vkCmdCopyBufferToImage2KHR(
-      VkCommandBuffer commandBuffer,
-      const VkCopyBufferToImageInfo2KHR *pCopyBufferToImageInfo) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdCopyBufferToImage2KHR(commandBuffer, pCopyBufferToImageInfo);
-  }
-
-  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 vkCmdCopyImage2KHR(VkCommandBuffer commandBuffer,
-                          const VkCopyImageInfo2KHR *pCopyImageInfo) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdCopyImage2KHR(commandBuffer, pCopyImageInfo);
-  }
-
-  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 vkCmdCopyImageToBuffer2KHR(
-      VkCommandBuffer commandBuffer,
-      const VkCopyImageToBufferInfo2KHR *pCopyImageToBufferInfo) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdCopyImageToBuffer2KHR(commandBuffer, pCopyImageToBufferInfo);
-  }
-
-  void vkCmdCopyMemoryToAccelerationStructureKHR(
-      VkCommandBuffer commandBuffer,
-      const VkCopyMemoryToAccelerationStructureInfoKHR *pInfo) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdCopyMemoryToAccelerationStructureKHR(commandBuffer, pInfo);
-  }
-
-  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 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 vkCmdDebugMarkerInsertEXT(
-      VkCommandBuffer commandBuffer,
-      const VkDebugMarkerMarkerInfoEXT *pMarkerInfo) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdDebugMarkerInsertEXT(commandBuffer, pMarkerInfo);
-  }
-
-  void vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX,
-                     uint32_t groupCountY,
-                     uint32_t groupCountZ) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdDispatch(commandBuffer, groupCountX, groupCountY,
-                           groupCountZ);
-  }
-
-  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 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);
-  }
-
-  void vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
-                             VkDeviceSize offset) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdDispatchIndirect(commandBuffer, buffer, offset);
-  }
-
-  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 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 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 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);
-  }
-
-  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);
-  }
-
-  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 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 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 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 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 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);
-  }
-
-  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 vkCmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount,
-                            uint32_t firstTask) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdDrawMeshTasksNV(commandBuffer, taskCount, firstTask);
-  }
-
-  void vkCmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdEndConditionalRenderingEXT(commandBuffer);
-  }
-
-  void vkCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdEndDebugUtilsLabelEXT(commandBuffer);
-  }
-
-  void vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
-                     uint32_t query) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdEndQuery(commandBuffer, queryPool, query);
-  }
-
-  void vkCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer,
-                               VkQueryPool queryPool, uint32_t query,
-                               uint32_t index) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdEndQueryIndexedEXT(commandBuffer, queryPool, query, index);
+  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
-  vkCmdEndRenderPass(VkCommandBuffer commandBuffer) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdEndRenderPass(commandBuffer);
+  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 vkCmdEndRenderPass2(VkCommandBuffer commandBuffer,
-                           const VkSubpassEndInfo *pSubpassEndInfo) const
+  void vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event,
+                     VkPipelineStageFlags stageMask) const VULKAN_HPP_NOEXCEPT {
+    return ::vkCmdSetEvent(commandBuffer, event, stageMask);
+  }
+
+  void
+  vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event,
+                  VkPipelineStageFlags stageMask) const VULKAN_HPP_NOEXCEPT {
+    return ::vkCmdResetEvent(commandBuffer, event, stageMask);
+  }
+
+  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 ::vkCmdEndRenderPass2(commandBuffer, pSubpassEndInfo);
-  }
-
-  void vkCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer,
-                              const VkSubpassEndInfo *pSubpassEndInfo) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdEndRenderPass2KHR(commandBuffer, pSubpassEndInfo);
-  }
-
-  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 vkCmdExecuteCommands(
-      VkCommandBuffer commandBuffer, uint32_t commandBufferCount,
-      const VkCommandBuffer *pCommandBuffers) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdExecuteCommands(commandBuffer, commandBufferCount,
-                                  pCommandBuffers);
-  }
-
-  void vkCmdExecuteGeneratedCommandsNV(
-      VkCommandBuffer commandBuffer, VkBool32 isPreprocessed,
-      const VkGeneratedCommandsInfoNV *pGeneratedCommandsInfo) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdExecuteGeneratedCommandsNV(commandBuffer, isPreprocessed,
-                                             pGeneratedCommandsInfo);
-  }
-
-  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 vkCmdInsertDebugUtilsLabelEXT(
-      VkCommandBuffer commandBuffer,
-      const VkDebugUtilsLabelEXT *pLabelInfo) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdInsertDebugUtilsLabelEXT(commandBuffer, pLabelInfo);
-  }
-
-  void vkCmdNextSubpass(VkCommandBuffer commandBuffer,
-                        VkSubpassContents contents) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdNextSubpass(commandBuffer, contents);
-  }
-
-  void vkCmdNextSubpass2(VkCommandBuffer commandBuffer,
-                         const VkSubpassBeginInfo *pSubpassBeginInfo,
-                         const VkSubpassEndInfo *pSubpassEndInfo) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdNextSubpass2(commandBuffer, pSubpassBeginInfo,
-                               pSubpassEndInfo);
-  }
-
-  void vkCmdNextSubpass2KHR(VkCommandBuffer commandBuffer,
-                            const VkSubpassBeginInfo *pSubpassBeginInfo,
-                            const VkSubpassEndInfo *pSubpassEndInfo) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdNextSubpass2KHR(commandBuffer, pSubpassBeginInfo,
-                                  pSubpassEndInfo);
+    return ::vkCmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask,
+                             dstStageMask, memoryBarrierCount, pMemoryBarriers,
+                             bufferMemoryBarrierCount, pBufferMemoryBarriers,
+                             imageMemoryBarrierCount, pImageMemoryBarriers);
   }
 
   void vkCmdPipelineBarrier(VkCommandBuffer commandBuffer,
@@ -1910,18 +2091,39 @@
         pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
   }
 
-  void vkCmdPipelineBarrier2KHR(
-      VkCommandBuffer commandBuffer,
-      const VkDependencyInfoKHR *pDependencyInfo) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdPipelineBarrier2KHR(commandBuffer, pDependencyInfo);
+  void vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
+                       uint32_t query,
+                       VkQueryControlFlags flags) const VULKAN_HPP_NOEXCEPT {
+    return ::vkCmdBeginQuery(commandBuffer, queryPool, query, flags);
   }
 
-  void vkCmdPreprocessGeneratedCommandsNV(
-      VkCommandBuffer commandBuffer,
-      const VkGeneratedCommandsInfoNV *pGeneratedCommandsInfo) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdPreprocessGeneratedCommandsNV(commandBuffer,
-                                                pGeneratedCommandsInfo);
+  void vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
+                     uint32_t query) const VULKAN_HPP_NOEXCEPT {
+    return ::vkCmdEndQuery(commandBuffer, queryPool, query);
+  }
+
+  void vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
+                           uint32_t firstQuery,
+                           uint32_t queryCount) const VULKAN_HPP_NOEXCEPT {
+    return ::vkCmdResetQueryPool(commandBuffer, queryPool, firstQuery,
+                                 queryCount);
+  }
+
+  void vkCmdWriteTimestamp(VkCommandBuffer commandBuffer,
+                           VkPipelineStageFlagBits pipelineStage,
+                           VkQueryPool queryPool,
+                           uint32_t query) const VULKAN_HPP_NOEXCEPT {
+    return ::vkCmdWriteTimestamp(commandBuffer, pipelineStage, 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 vkCmdPushConstants(VkCommandBuffer commandBuffer,
@@ -1933,6 +2135,1000 @@
                                 pValues);
   }
 
+  void
+  vkCmdBeginRenderPass(VkCommandBuffer commandBuffer,
+                       const VkRenderPassBeginInfo *pRenderPassBegin,
+                       VkSubpassContents contents) const VULKAN_HPP_NOEXCEPT {
+    return ::vkCmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents);
+  }
+
+  void vkCmdNextSubpass(VkCommandBuffer commandBuffer,
+                        VkSubpassContents contents) const VULKAN_HPP_NOEXCEPT {
+    return ::vkCmdNextSubpass(commandBuffer, contents);
+  }
+
+  void
+  vkCmdEndRenderPass(VkCommandBuffer commandBuffer) const VULKAN_HPP_NOEXCEPT {
+    return ::vkCmdEndRenderPass(commandBuffer);
+  }
+
+  void vkCmdExecuteCommands(
+      VkCommandBuffer commandBuffer, uint32_t commandBufferCount,
+      const VkCommandBuffer *pCommandBuffers) const VULKAN_HPP_NOEXCEPT {
+    return ::vkCmdExecuteCommands(commandBuffer, commandBufferCount,
+                                  pCommandBuffers);
+  }
+
+  //=== VK_VERSION_1_1 ===
+
+  VkResult
+  vkEnumerateInstanceVersion(uint32_t *pApiVersion) const VULKAN_HPP_NOEXCEPT {
+    return ::vkEnumerateInstanceVersion(pApiVersion);
+  }
+
+  VkResult vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount,
+                               const VkBindBufferMemoryInfo *pBindInfos) const
+      VULKAN_HPP_NOEXCEPT {
+    return ::vkBindBufferMemory2(device, bindInfoCount, pBindInfos);
+  }
+
+  VkResult vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount,
+                              const VkBindImageMemoryInfo *pBindInfos) const
+      VULKAN_HPP_NOEXCEPT {
+    return ::vkBindImageMemory2(device, bindInfoCount, pBindInfos);
+  }
+
+  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);
+  }
+
+  void vkCmdSetDeviceMask(VkCommandBuffer commandBuffer,
+                          uint32_t deviceMask) const VULKAN_HPP_NOEXCEPT {
+    return ::vkCmdSetDeviceMask(commandBuffer, deviceMask);
+  }
+
+  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);
+  }
+
+  VkResult vkEnumeratePhysicalDeviceGroups(
+      VkInstance instance, uint32_t *pPhysicalDeviceGroupCount,
+      VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties) const
+      VULKAN_HPP_NOEXCEPT {
+    return ::vkEnumeratePhysicalDeviceGroups(
+        instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
+  }
+
+  void vkGetImageMemoryRequirements2(
+      VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo,
+      VkMemoryRequirements2 *pMemoryRequirements) const VULKAN_HPP_NOEXCEPT {
+    return ::vkGetImageMemoryRequirements2(device, pInfo, pMemoryRequirements);
+  }
+
+  void vkGetBufferMemoryRequirements2(
+      VkDevice device, const VkBufferMemoryRequirementsInfo2 *pInfo,
+      VkMemoryRequirements2 *pMemoryRequirements) const VULKAN_HPP_NOEXCEPT {
+    return ::vkGetBufferMemoryRequirements2(device, pInfo, pMemoryRequirements);
+  }
+
+  void vkGetImageSparseMemoryRequirements2(
+      VkDevice device, const VkImageSparseMemoryRequirementsInfo2 *pInfo,
+      uint32_t *pSparseMemoryRequirementCount,
+      VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements) const
+      VULKAN_HPP_NOEXCEPT {
+    return ::vkGetImageSparseMemoryRequirements2(device, pInfo,
+                                                 pSparseMemoryRequirementCount,
+                                                 pSparseMemoryRequirements);
+  }
+
+  void vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice,
+                                    VkPhysicalDeviceFeatures2 *pFeatures) const
+      VULKAN_HPP_NOEXCEPT {
+    return ::vkGetPhysicalDeviceFeatures2(physicalDevice, pFeatures);
+  }
+
+  void vkGetPhysicalDeviceProperties2(
+      VkPhysicalDevice physicalDevice,
+      VkPhysicalDeviceProperties2 *pProperties) const VULKAN_HPP_NOEXCEPT {
+    return ::vkGetPhysicalDeviceProperties2(physicalDevice, pProperties);
+  }
+
+  void vkGetPhysicalDeviceFormatProperties2(
+      VkPhysicalDevice physicalDevice, VkFormat format,
+      VkFormatProperties2 *pFormatProperties) const VULKAN_HPP_NOEXCEPT {
+    return ::vkGetPhysicalDeviceFormatProperties2(physicalDevice, format,
+                                                  pFormatProperties);
+  }
+
+  VkResult vkGetPhysicalDeviceImageFormatProperties2(
+      VkPhysicalDevice physicalDevice,
+      const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo,
+      VkImageFormatProperties2 *pImageFormatProperties) const
+      VULKAN_HPP_NOEXCEPT {
+    return ::vkGetPhysicalDeviceImageFormatProperties2(
+        physicalDevice, pImageFormatInfo, pImageFormatProperties);
+  }
+
+  void vkGetPhysicalDeviceQueueFamilyProperties2(
+      VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount,
+      VkQueueFamilyProperties2 *pQueueFamilyProperties) const
+      VULKAN_HPP_NOEXCEPT {
+    return ::vkGetPhysicalDeviceQueueFamilyProperties2(
+        physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
+  }
+
+  void vkGetPhysicalDeviceMemoryProperties2(
+      VkPhysicalDevice physicalDevice,
+      VkPhysicalDeviceMemoryProperties2 *pMemoryProperties) const
+      VULKAN_HPP_NOEXCEPT {
+    return ::vkGetPhysicalDeviceMemoryProperties2(physicalDevice,
+                                                  pMemoryProperties);
+  }
+
+  void vkGetPhysicalDeviceSparseImageFormatProperties2(
+      VkPhysicalDevice physicalDevice,
+      const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo,
+      uint32_t *pPropertyCount,
+      VkSparseImageFormatProperties2 *pProperties) const VULKAN_HPP_NOEXCEPT {
+    return ::vkGetPhysicalDeviceSparseImageFormatProperties2(
+        physicalDevice, pFormatInfo, pPropertyCount, pProperties);
+  }
+
+  void
+  vkTrimCommandPool(VkDevice device, VkCommandPool commandPool,
+                    VkCommandPoolTrimFlags flags) const VULKAN_HPP_NOEXCEPT {
+    return ::vkTrimCommandPool(device, commandPool, flags);
+  }
+
+  void vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2 *pQueueInfo,
+                         VkQueue *pQueue) const VULKAN_HPP_NOEXCEPT {
+    return ::vkGetDeviceQueue2(device, pQueueInfo, pQueue);
+  }
+
+  VkResult vkCreateSamplerYcbcrConversion(
+      VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo,
+      const VkAllocationCallbacks *pAllocator,
+      VkSamplerYcbcrConversion *pYcbcrConversion) const VULKAN_HPP_NOEXCEPT {
+    return ::vkCreateSamplerYcbcrConversion(device, pCreateInfo, pAllocator,
+                                            pYcbcrConversion);
+  }
+
+  void vkDestroySamplerYcbcrConversion(
+      VkDevice device, VkSamplerYcbcrConversion ycbcrConversion,
+      const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT {
+    return ::vkDestroySamplerYcbcrConversion(device, ycbcrConversion,
+                                             pAllocator);
+  }
+
+  VkResult vkCreateDescriptorUpdateTemplate(
+      VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo,
+      const VkAllocationCallbacks *pAllocator,
+      VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate) const
+      VULKAN_HPP_NOEXCEPT {
+    return ::vkCreateDescriptorUpdateTemplate(device, pCreateInfo, pAllocator,
+                                              pDescriptorUpdateTemplate);
+  }
+
+  void vkDestroyDescriptorUpdateTemplate(
+      VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+      const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT {
+    return ::vkDestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate,
+                                               pAllocator);
+  }
+
+  void vkUpdateDescriptorSetWithTemplate(
+      VkDevice device, VkDescriptorSet descriptorSet,
+      VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+      const void *pData) const VULKAN_HPP_NOEXCEPT {
+    return ::vkUpdateDescriptorSetWithTemplate(device, descriptorSet,
+                                               descriptorUpdateTemplate, pData);
+  }
+
+  void vkGetPhysicalDeviceExternalBufferProperties(
+      VkPhysicalDevice physicalDevice,
+      const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo,
+      VkExternalBufferProperties *pExternalBufferProperties) const
+      VULKAN_HPP_NOEXCEPT {
+    return ::vkGetPhysicalDeviceExternalBufferProperties(
+        physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
+  }
+
+  void vkGetPhysicalDeviceExternalFenceProperties(
+      VkPhysicalDevice physicalDevice,
+      const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo,
+      VkExternalFenceProperties *pExternalFenceProperties) const
+      VULKAN_HPP_NOEXCEPT {
+    return ::vkGetPhysicalDeviceExternalFenceProperties(
+        physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
+  }
+
+  void vkGetPhysicalDeviceExternalSemaphoreProperties(
+      VkPhysicalDevice physicalDevice,
+      const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo,
+      VkExternalSemaphoreProperties *pExternalSemaphoreProperties) const
+      VULKAN_HPP_NOEXCEPT {
+    return ::vkGetPhysicalDeviceExternalSemaphoreProperties(
+        physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
+  }
+
+  void vkGetDescriptorSetLayoutSupport(
+      VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo,
+      VkDescriptorSetLayoutSupport *pSupport) const VULKAN_HPP_NOEXCEPT {
+    return ::vkGetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport);
+  }
+
+  //=== VK_VERSION_1_2 ===
+
+  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 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);
+  }
+
+  VkResult
+  vkCreateRenderPass2(VkDevice device,
+                      const VkRenderPassCreateInfo2 *pCreateInfo,
+                      const VkAllocationCallbacks *pAllocator,
+                      VkRenderPass *pRenderPass) const VULKAN_HPP_NOEXCEPT {
+    return ::vkCreateRenderPass2(device, pCreateInfo, pAllocator, pRenderPass);
+  }
+
+  void vkCmdBeginRenderPass2(VkCommandBuffer commandBuffer,
+                             const VkRenderPassBeginInfo *pRenderPassBegin,
+                             const VkSubpassBeginInfo *pSubpassBeginInfo) const
+      VULKAN_HPP_NOEXCEPT {
+    return ::vkCmdBeginRenderPass2(commandBuffer, pRenderPassBegin,
+                                   pSubpassBeginInfo);
+  }
+
+  void vkCmdNextSubpass2(VkCommandBuffer commandBuffer,
+                         const VkSubpassBeginInfo *pSubpassBeginInfo,
+                         const VkSubpassEndInfo *pSubpassEndInfo) const
+      VULKAN_HPP_NOEXCEPT {
+    return ::vkCmdNextSubpass2(commandBuffer, pSubpassBeginInfo,
+                               pSubpassEndInfo);
+  }
+
+  void vkCmdEndRenderPass2(VkCommandBuffer commandBuffer,
+                           const VkSubpassEndInfo *pSubpassEndInfo) const
+      VULKAN_HPP_NOEXCEPT {
+    return ::vkCmdEndRenderPass2(commandBuffer, pSubpassEndInfo);
+  }
+
+  void vkResetQueryPool(VkDevice device, VkQueryPool queryPool,
+                        uint32_t firstQuery,
+                        uint32_t queryCount) const VULKAN_HPP_NOEXCEPT {
+    return ::vkResetQueryPool(device, queryPool, firstQuery, queryCount);
+  }
+
+  VkResult
+  vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore,
+                             uint64_t *pValue) const VULKAN_HPP_NOEXCEPT {
+    return ::vkGetSemaphoreCounterValue(device, semaphore, pValue);
+  }
+
+  VkResult vkWaitSemaphores(VkDevice device,
+                            const VkSemaphoreWaitInfo *pWaitInfo,
+                            uint64_t timeout) const VULKAN_HPP_NOEXCEPT {
+    return ::vkWaitSemaphores(device, pWaitInfo, timeout);
+  }
+
+  VkResult vkSignalSemaphore(VkDevice device,
+                             const VkSemaphoreSignalInfo *pSignalInfo) const
+      VULKAN_HPP_NOEXCEPT {
+    return ::vkSignalSemaphore(device, pSignalInfo);
+  }
+
+  VkDeviceAddress vkGetBufferDeviceAddress(
+      VkDevice device,
+      const VkBufferDeviceAddressInfo *pInfo) const VULKAN_HPP_NOEXCEPT {
+    return ::vkGetBufferDeviceAddress(device, pInfo);
+  }
+
+  uint64_t vkGetBufferOpaqueCaptureAddress(
+      VkDevice device,
+      const VkBufferDeviceAddressInfo *pInfo) const VULKAN_HPP_NOEXCEPT {
+    return ::vkGetBufferOpaqueCaptureAddress(device, pInfo);
+  }
+
+  uint64_t vkGetDeviceMemoryOpaqueCaptureAddress(
+      VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo *pInfo)
+      const VULKAN_HPP_NOEXCEPT {
+    return ::vkGetDeviceMemoryOpaqueCaptureAddress(device, pInfo);
+  }
+
+  //=== VK_KHR_surface ===
+
+  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 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 vkGetPhysicalDeviceSurfacePresentModesKHR(
+      VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
+      uint32_t *pPresentModeCount,
+      VkPresentModeKHR *pPresentModes) const VULKAN_HPP_NOEXCEPT {
+    return ::vkGetPhysicalDeviceSurfacePresentModesKHR(
+        physicalDevice, surface, pPresentModeCount, pPresentModes);
+  }
+
+  //=== 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);
+  }
+
+  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
+  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 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 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);
+  }
+
+  //=== VK_KHR_display ===
+
+  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 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
+  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 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 ===
+
+  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 ===
+
+  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);
+  }
+#endif /*VK_USE_PLATFORM_XLIB_KHR*/
+
+#if defined(VK_USE_PLATFORM_XCB_KHR)
+
+  //=== 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);
+  }
+
+  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 ===
+
+  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);
+  }
+#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
+
+#if defined(VK_USE_PLATFORM_ANDROID_KHR)
+
+  //=== 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);
+  }
+#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+
+#if defined(VK_USE_PLATFORM_WIN32_KHR)
+
+  //=== 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);
+  }
+
+  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 ===
+
+  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 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 ===
+
+  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);
+  }
+
+  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 vkCmdDebugMarkerInsertEXT(
+      VkCommandBuffer commandBuffer,
+      const VkDebugMarkerMarkerInfoEXT *pMarkerInfo) const VULKAN_HPP_NOEXCEPT {
+    return ::vkCmdDebugMarkerInsertEXT(commandBuffer, pMarkerInfo);
+  }
+
+  //=== 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 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 ::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 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);
+  }
+
+  //=== VK_NVX_image_view_handle ===
+
+  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);
+  }
+
+  //=== 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 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);
+  }
+
+#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,
@@ -1951,50 +3147,720 @@
         commandBuffer, descriptorUpdateTemplate, layout, set, pData);
   }
 
-  void
-  vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event,
-                  VkPipelineStageFlags stageMask) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdResetEvent(commandBuffer, event, stageMask);
-  }
+  //=== VK_EXT_conditional_rendering ===
 
-  void vkCmdResetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event,
-                           VkPipelineStageFlags2KHR stageMask) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdResetEvent2KHR(commandBuffer, event, stageMask);
-  }
-
-  void vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
-                           uint32_t firstQuery,
-                           uint32_t queryCount) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdResetQueryPool(commandBuffer, queryPool, firstQuery,
-                                 queryCount);
-  }
-
-  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 vkCmdResolveImage2KHR(VkCommandBuffer commandBuffer,
-                             const VkResolveImageInfo2KHR *pResolveImageInfo)
+  void vkCmdBeginConditionalRenderingEXT(
+      VkCommandBuffer commandBuffer,
+      const VkConditionalRenderingBeginInfoEXT *pConditionalRenderingBegin)
       const VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdResolveImage2KHR(commandBuffer, pResolveImageInfo);
+    return ::vkCmdBeginConditionalRenderingEXT(commandBuffer,
+                                               pConditionalRenderingBegin);
   }
 
-  void vkCmdSetBlendConstants(VkCommandBuffer commandBuffer,
-                              const float blendConstants[4]) const
+  void vkCmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer) const
       VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdSetBlendConstants(commandBuffer, blendConstants);
+    return ::vkCmdEndConditionalRenderingEXT(commandBuffer);
   }
 
-  void vkCmdSetCheckpointNV(VkCommandBuffer commandBuffer,
-                            const void *pCheckpointMarker) const
+  //=== VK_KHR_descriptor_update_template ===
+
+  VkResult vkCreateDescriptorUpdateTemplateKHR(
+      VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo,
+      const VkAllocationCallbacks *pAllocator,
+      VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate) const
       VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdSetCheckpointNV(commandBuffer, pCheckpointMarker);
+    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);
+  }
+
+  //=== 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*/
+
+  //=== 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_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(
@@ -2007,266 +3873,55 @@
                                          pCustomSampleOrders);
   }
 
-  void vkCmdSetCullModeEXT(VkCommandBuffer commandBuffer,
-                           VkCullModeFlags cullMode) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdSetCullModeEXT(commandBuffer, cullMode);
-  }
+  //=== VK_NV_ray_tracing ===
 
-  void vkCmdSetDepthBias(VkCommandBuffer commandBuffer,
-                         float depthBiasConstantFactor, float depthBiasClamp,
-                         float depthBiasSlopeFactor) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdSetDepthBias(commandBuffer, depthBiasConstantFactor,
-                               depthBiasClamp, depthBiasSlopeFactor);
-  }
-
-  void vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds,
-                           float maxDepthBounds) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds);
-  }
-
-  void vkCmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer,
-                                        VkBool32 depthBoundsTestEnable) const
+  VkResult vkCreateAccelerationStructureNV(
+      VkDevice device, const VkAccelerationStructureCreateInfoNV *pCreateInfo,
+      const VkAllocationCallbacks *pAllocator,
+      VkAccelerationStructureNV *pAccelerationStructure) const
       VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdSetDepthBoundsTestEnableEXT(commandBuffer,
-                                              depthBoundsTestEnable);
+    return ::vkCreateAccelerationStructureNV(device, pCreateInfo, pAllocator,
+                                             pAccelerationStructure);
   }
 
-  void vkCmdSetDepthCompareOpEXT(VkCommandBuffer commandBuffer,
-                                 VkCompareOp depthCompareOp) const
+  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 ::vkCmdSetDepthCompareOpEXT(commandBuffer, depthCompareOp);
+    return ::vkBindAccelerationStructureMemoryNV(device, bindInfoCount,
+                                                 pBindInfos);
   }
 
-  void vkCmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer,
-                                  VkBool32 depthTestEnable) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdSetDepthTestEnableEXT(commandBuffer, depthTestEnable);
+  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 vkCmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer,
-                                   VkBool32 depthWriteEnable) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdSetDepthWriteEnableEXT(commandBuffer, depthWriteEnable);
-  }
-
-  void vkCmdSetDeviceMask(VkCommandBuffer commandBuffer,
-                          uint32_t deviceMask) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdSetDeviceMask(commandBuffer, deviceMask);
-  }
-
-  void vkCmdSetDeviceMaskKHR(VkCommandBuffer commandBuffer,
-                             uint32_t deviceMask) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdSetDeviceMaskKHR(commandBuffer, deviceMask);
-  }
-
-  void vkCmdSetDiscardRectangleEXT(
-      VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle,
-      uint32_t discardRectangleCount,
-      const VkRect2D *pDiscardRectangles) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdSetDiscardRectangleEXT(commandBuffer, firstDiscardRectangle,
-                                         discardRectangleCount,
-                                         pDiscardRectangles);
-  }
-
-  void vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event,
-                     VkPipelineStageFlags stageMask) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdSetEvent(commandBuffer, event, stageMask);
-  }
-
-  void vkCmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event,
-                         const VkDependencyInfoKHR *pDependencyInfo) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdSetEvent2KHR(commandBuffer, event, pDependencyInfo);
-  }
-
-  void vkCmdSetExclusiveScissorNV(
-      VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor,
-      uint32_t exclusiveScissorCount,
-      const VkRect2D *pExclusiveScissors) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdSetExclusiveScissorNV(commandBuffer, firstExclusiveScissor,
-                                        exclusiveScissorCount,
-                                        pExclusiveScissors);
-  }
-
-  void vkCmdSetFragmentShadingRateEnumNV(
-      VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate,
-      const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdSetFragmentShadingRateEnumNV(commandBuffer, shadingRate,
-                                               combinerOps);
-  }
-
-  void vkCmdSetFragmentShadingRateKHR(
-      VkCommandBuffer commandBuffer, const VkExtent2D *pFragmentSize,
-      const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdSetFragmentShadingRateKHR(commandBuffer, pFragmentSize,
-                                            combinerOps);
-  }
-
-  void vkCmdSetFrontFaceEXT(VkCommandBuffer commandBuffer,
-                            VkFrontFace frontFace) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdSetFrontFaceEXT(commandBuffer, frontFace);
-  }
-
-  void vkCmdSetLineStippleEXT(
-      VkCommandBuffer commandBuffer, uint32_t lineStippleFactor,
-      uint16_t lineStipplePattern) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdSetLineStippleEXT(commandBuffer, lineStippleFactor,
-                                    lineStipplePattern);
-  }
-
-  void vkCmdSetLineWidth(VkCommandBuffer commandBuffer,
-                         float lineWidth) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdSetLineWidth(commandBuffer, lineWidth);
-  }
-
-  VkResult vkCmdSetPerformanceMarkerINTEL(
-      VkCommandBuffer commandBuffer,
-      const VkPerformanceMarkerInfoINTEL *pMarkerInfo) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdSetPerformanceMarkerINTEL(commandBuffer, pMarkerInfo);
-  }
-
-  VkResult vkCmdSetPerformanceOverrideINTEL(
-      VkCommandBuffer commandBuffer,
-      const VkPerformanceOverrideInfoINTEL *pOverrideInfo) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdSetPerformanceOverrideINTEL(commandBuffer, pOverrideInfo);
-  }
-
-  VkResult vkCmdSetPerformanceStreamMarkerINTEL(
-      VkCommandBuffer commandBuffer,
-      const VkPerformanceStreamMarkerInfoINTEL *pMarkerInfo) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdSetPerformanceStreamMarkerINTEL(commandBuffer, pMarkerInfo);
-  }
-
-  void vkCmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer,
-                                    VkPrimitiveTopology primitiveTopology) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdSetPrimitiveTopologyEXT(commandBuffer, primitiveTopology);
-  }
-
-  void vkCmdSetRayTracingPipelineStackSizeKHR(VkCommandBuffer commandBuffer,
-                                              uint32_t pipelineStackSize) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdSetRayTracingPipelineStackSizeKHR(commandBuffer,
-                                                    pipelineStackSize);
-  }
-
-  void vkCmdSetSampleLocationsEXT(
-      VkCommandBuffer commandBuffer,
-      const VkSampleLocationsInfoEXT *pSampleLocationsInfo) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdSetSampleLocationsEXT(commandBuffer, pSampleLocationsInfo);
-  }
-
-  void vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor,
-                       uint32_t scissorCount,
-                       const VkRect2D *pScissors) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdSetScissor(commandBuffer, firstScissor, scissorCount,
-                             pScissors);
-  }
-
-  void vkCmdSetScissorWithCountEXT(
-      VkCommandBuffer commandBuffer, uint32_t scissorCount,
-      const VkRect2D *pScissors) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdSetScissorWithCountEXT(commandBuffer, scissorCount,
-                                         pScissors);
-  }
-
-  void
-  vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer,
-                             VkStencilFaceFlags faceMask,
-                             uint32_t compareMask) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdSetStencilCompareMask(commandBuffer, faceMask, compareMask);
-  }
-
-  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);
-  }
-
-  void vkCmdSetStencilReference(VkCommandBuffer commandBuffer,
-                                VkStencilFaceFlags faceMask,
-                                uint32_t reference) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdSetStencilReference(commandBuffer, faceMask, reference);
-  }
-
-  void vkCmdSetStencilTestEnableEXT(VkCommandBuffer commandBuffer,
-                                    VkBool32 stencilTestEnable) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdSetStencilTestEnableEXT(commandBuffer, stencilTestEnable);
-  }
-
-  void vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer,
-                                VkStencilFaceFlags faceMask,
-                                uint32_t writeMask) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdSetStencilWriteMask(commandBuffer, faceMask, writeMask);
-  }
-
-  void
-  vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport,
-                   uint32_t viewportCount,
-                   const VkViewport *pViewports) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdSetViewport(commandBuffer, firstViewport, viewportCount,
-                              pViewports);
-  }
-
-  void vkCmdSetViewportShadingRatePaletteNV(
-      VkCommandBuffer commandBuffer, uint32_t firstViewport,
-      uint32_t viewportCount,
-      const VkShadingRatePaletteNV *pShadingRatePalettes) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdSetViewportShadingRatePaletteNV(
-        commandBuffer, firstViewport, viewportCount, pShadingRatePalettes);
-  }
-
-  void
-  vkCmdSetViewportWScalingNV(VkCommandBuffer commandBuffer,
-                             uint32_t firstViewport, uint32_t viewportCount,
-                             const VkViewportWScalingNV *pViewportWScalings)
-      const VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdSetViewportWScalingNV(commandBuffer, firstViewport,
-                                        viewportCount, pViewportWScalings);
-  }
-
-  void vkCmdSetViewportWithCountEXT(
-      VkCommandBuffer commandBuffer, uint32_t viewportCount,
-      const VkViewport *pViewports) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdSetViewportWithCountEXT(commandBuffer, viewportCount,
-                                          pViewports);
-  }
-
-  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);
-  }
-
-  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);
+  void vkCmdCopyAccelerationStructureNV(
+      VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst,
+      VkAccelerationStructureNV src,
+      VkCopyAccelerationStructureModeKHR mode) const VULKAN_HPP_NOEXCEPT {
+    return ::vkCmdCopyAccelerationStructureNV(commandBuffer, dst, src, mode);
   }
 
   void vkCmdTraceRaysNV(VkCommandBuffer commandBuffer,
@@ -2293,46 +3948,30 @@
         depth);
   }
 
-  void vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer,
-                         VkDeviceSize dstOffset, VkDeviceSize dataSize,
-                         const void *pData) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize,
-                               pData);
+  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);
   }
 
-  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);
+  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);
   }
 
-  void vkCmdWaitEvents2KHR(VkCommandBuffer commandBuffer, uint32_t eventCount,
-                           const VkEvent *pEvents,
-                           const VkDependencyInfoKHR *pDependencyInfos) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdWaitEvents2KHR(commandBuffer, eventCount, pEvents,
-                                 pDependencyInfos);
-  }
-
-  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);
+  VkResult vkGetAccelerationStructureHandleNV(
+      VkDevice device, VkAccelerationStructureNV accelerationStructure,
+      size_t dataSize, void *pData) const VULKAN_HPP_NOEXCEPT {
+    return ::vkGetAccelerationStructureHandleNV(device, accelerationStructure,
+                                                dataSize, pData);
   }
 
   void vkCmdWriteAccelerationStructuresPropertiesNV(
@@ -2345,14 +3984,53 @@
         queryType, queryPool, firstQuery);
   }
 
-  void vkCmdWriteBufferMarker2AMD(VkCommandBuffer commandBuffer,
-                                  VkPipelineStageFlags2KHR stage,
-                                  VkBuffer dstBuffer, VkDeviceSize dstOffset,
-                                  uint32_t marker) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdWriteBufferMarker2AMD(commandBuffer, stage, dstBuffer,
-                                        dstOffset, marker);
+  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,
@@ -2361,270 +4039,168 @@
                                        dstOffset, marker);
   }
 
-  void vkCmdWriteTimestamp(VkCommandBuffer commandBuffer,
-                           VkPipelineStageFlagBits pipelineStage,
-                           VkQueryPool queryPool,
-                           uint32_t query) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdWriteTimestamp(commandBuffer, pipelineStage, queryPool,
-                                 query);
+  //=== VK_EXT_calibrated_timestamps ===
+
+  VkResult vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(
+      VkPhysicalDevice physicalDevice, uint32_t *pTimeDomainCount,
+      VkTimeDomainEXT *pTimeDomains) const VULKAN_HPP_NOEXCEPT {
+    return ::vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(
+        physicalDevice, pTimeDomainCount, pTimeDomains);
   }
 
-  void vkCmdWriteTimestamp2KHR(VkCommandBuffer commandBuffer,
-                               VkPipelineStageFlags2KHR stage,
-                               VkQueryPool queryPool,
-                               uint32_t query) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCmdWriteTimestamp2KHR(commandBuffer, stage, queryPool, query);
+  VkResult vkGetCalibratedTimestampsEXT(
+      VkDevice device, uint32_t timestampCount,
+      const VkCalibratedTimestampInfoEXT *pTimestampInfos,
+      uint64_t *pTimestamps,
+      uint64_t *pMaxDeviation) const VULKAN_HPP_NOEXCEPT {
+    return ::vkGetCalibratedTimestampsEXT(
+        device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation);
   }
 
-  VkResult vkCompileDeferredNV(VkDevice device, VkPipeline pipeline,
-                               uint32_t shader) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCompileDeferredNV(device, pipeline, shader);
+  //=== VK_NV_mesh_shader ===
+
+  void vkCmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount,
+                            uint32_t firstTask) const VULKAN_HPP_NOEXCEPT {
+    return ::vkCmdDrawMeshTasksNV(commandBuffer, taskCount, firstTask);
   }
 
-  VkResult vkCopyAccelerationStructureKHR(
-      VkDevice device, VkDeferredOperationKHR deferredOperation,
-      const VkCopyAccelerationStructureInfoKHR *pInfo) const
+  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 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 ::vkCopyAccelerationStructureKHR(device, deferredOperation, pInfo);
+    return ::vkCmdSetCheckpointNV(commandBuffer, pCheckpointMarker);
   }
 
-  VkResult vkCopyAccelerationStructureToMemoryKHR(
-      VkDevice device, VkDeferredOperationKHR deferredOperation,
-      const VkCopyAccelerationStructureToMemoryInfoKHR *pInfo) const
+  void vkGetQueueCheckpointDataNV(VkQueue queue, uint32_t *pCheckpointDataCount,
+                                  VkCheckpointDataNV *pCheckpointData) const
       VULKAN_HPP_NOEXCEPT {
-    return ::vkCopyAccelerationStructureToMemoryKHR(device, deferredOperation,
-                                                    pInfo);
+    return ::vkGetQueueCheckpointDataNV(queue, pCheckpointDataCount,
+                                        pCheckpointData);
   }
 
-  VkResult vkCopyMemoryToAccelerationStructureKHR(
-      VkDevice device, VkDeferredOperationKHR deferredOperation,
-      const VkCopyMemoryToAccelerationStructureInfoKHR *pInfo) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkCopyMemoryToAccelerationStructureKHR(device, deferredOperation,
-                                                    pInfo);
-  }
+  //=== VK_KHR_timeline_semaphore ===
 
-  VkResult vkCreateAccelerationStructureKHR(
-      VkDevice device, const VkAccelerationStructureCreateInfoKHR *pCreateInfo,
-      const VkAllocationCallbacks *pAllocator,
-      VkAccelerationStructureKHR *pAccelerationStructure) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkCreateAccelerationStructureKHR(device, pCreateInfo, pAllocator,
-                                              pAccelerationStructure);
-  }
-
-  VkResult vkCreateAccelerationStructureNV(
-      VkDevice device, const VkAccelerationStructureCreateInfoNV *pCreateInfo,
-      const VkAllocationCallbacks *pAllocator,
-      VkAccelerationStructureNV *pAccelerationStructure) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkCreateAccelerationStructureNV(device, pCreateInfo, pAllocator,
-                                             pAccelerationStructure);
-  }
-
-#if defined(VK_USE_PLATFORM_ANDROID_KHR)
   VkResult
-  vkCreateAndroidSurfaceKHR(VkInstance instance,
-                            const VkAndroidSurfaceCreateInfoKHR *pCreateInfo,
-                            const VkAllocationCallbacks *pAllocator,
-                            VkSurfaceKHR *pSurface) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCreateAndroidSurfaceKHR(instance, pCreateInfo, pAllocator,
-                                       pSurface);
+  vkGetSemaphoreCounterValueKHR(VkDevice device, VkSemaphore semaphore,
+                                uint64_t *pValue) const VULKAN_HPP_NOEXCEPT {
+    return ::vkGetSemaphoreCounterValueKHR(device, semaphore, pValue);
   }
-#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
 
-  VkResult vkCreateBuffer(VkDevice device,
-                          const VkBufferCreateInfo *pCreateInfo,
-                          const VkAllocationCallbacks *pAllocator,
-                          VkBuffer *pBuffer) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
+  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)
-  VkResult vkCreateBufferCollectionFUCHSIA(
-      VkDevice device, const VkBufferCollectionCreateInfoFUCHSIA *pImportInfo,
-      const VkAllocationCallbacks *pAllocator,
-      VkBufferCollectionFUCHSIA *pCollection) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCreateBufferCollectionFUCHSIA(device, pImportInfo, pAllocator,
-                                             pCollection);
-  }
-#endif /*VK_USE_PLATFORM_FUCHSIA*/
 
-  VkResult vkCreateBufferView(VkDevice device,
-                              const VkBufferViewCreateInfo *pCreateInfo,
-                              const VkAllocationCallbacks *pAllocator,
-                              VkBufferView *pView) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCreateBufferView(device, pCreateInfo, pAllocator, pView);
-  }
+  //=== VK_FUCHSIA_imagepipe_surface ===
 
-  VkResult
-  vkCreateCommandPool(VkDevice device,
-                      const VkCommandPoolCreateInfo *pCreateInfo,
-                      const VkAllocationCallbacks *pAllocator,
-                      VkCommandPool *pCommandPool) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool);
-  }
-
-  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);
-  }
-
-  VkResult vkCreateDebugReportCallbackEXT(
-      VkInstance instance,
-      const VkDebugReportCallbackCreateInfoEXT *pCreateInfo,
-      const VkAllocationCallbacks *pAllocator,
-      VkDebugReportCallbackEXT *pCallback) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator,
-                                            pCallback);
-  }
-
-  VkResult vkCreateDebugUtilsMessengerEXT(
-      VkInstance instance,
-      const VkDebugUtilsMessengerCreateInfoEXT *pCreateInfo,
-      const VkAllocationCallbacks *pAllocator,
-      VkDebugUtilsMessengerEXT *pMessenger) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCreateDebugUtilsMessengerEXT(instance, pCreateInfo, pAllocator,
-                                            pMessenger);
-  }
-
-  VkResult vkCreateDeferredOperationKHR(
-      VkDevice device, const VkAllocationCallbacks *pAllocator,
-      VkDeferredOperationKHR *pDeferredOperation) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCreateDeferredOperationKHR(device, pAllocator,
-                                          pDeferredOperation);
-  }
-
-  VkResult vkCreateDescriptorPool(
-      VkDevice device, const VkDescriptorPoolCreateInfo *pCreateInfo,
-      const VkAllocationCallbacks *pAllocator,
-      VkDescriptorPool *pDescriptorPool) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCreateDescriptorPool(device, pCreateInfo, pAllocator,
-                                    pDescriptorPool);
-  }
-
-  VkResult vkCreateDescriptorSetLayout(
-      VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo,
-      const VkAllocationCallbacks *pAllocator,
-      VkDescriptorSetLayout *pSetLayout) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCreateDescriptorSetLayout(device, pCreateInfo, pAllocator,
-                                         pSetLayout);
-  }
-
-  VkResult vkCreateDescriptorUpdateTemplate(
-      VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo,
-      const VkAllocationCallbacks *pAllocator,
-      VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkCreateDescriptorUpdateTemplate(device, pCreateInfo, pAllocator,
-                                              pDescriptorUpdateTemplate);
-  }
-
-  VkResult vkCreateDescriptorUpdateTemplateKHR(
-      VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo,
-      const VkAllocationCallbacks *pAllocator,
-      VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkCreateDescriptorUpdateTemplateKHR(
-        device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
-  }
-
-  VkResult vkCreateDevice(VkPhysicalDevice physicalDevice,
-                          const VkDeviceCreateInfo *pCreateInfo,
-                          const VkAllocationCallbacks *pAllocator,
-                          VkDevice *pDevice) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice);
-  }
-
-#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
-  VkResult
-  vkCreateDirectFBSurfaceEXT(VkInstance instance,
-                             const VkDirectFBSurfaceCreateInfoEXT *pCreateInfo,
-                             const VkAllocationCallbacks *pAllocator,
-                             VkSurfaceKHR *pSurface) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCreateDirectFBSurfaceEXT(instance, pCreateInfo, pAllocator,
-                                        pSurface);
-  }
-#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
-
-  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 vkCreateDisplayPlaneSurfaceKHR(
-      VkInstance instance, const VkDisplaySurfaceCreateInfoKHR *pCreateInfo,
-      const VkAllocationCallbacks *pAllocator,
-      VkSurfaceKHR *pSurface) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCreateDisplayPlaneSurfaceKHR(instance, pCreateInfo, pAllocator,
-                                            pSurface);
-  }
-
-  VkResult vkCreateEvent(VkDevice device, const VkEventCreateInfo *pCreateInfo,
-                         const VkAllocationCallbacks *pAllocator,
-                         VkEvent *pEvent) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCreateEvent(device, pCreateInfo, pAllocator, pEvent);
-  }
-
-  VkResult vkCreateFence(VkDevice device, const VkFenceCreateInfo *pCreateInfo,
-                         const VkAllocationCallbacks *pAllocator,
-                         VkFence *pFence) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCreateFence(device, pCreateInfo, pAllocator, pFence);
-  }
-
-  VkResult
-  vkCreateFramebuffer(VkDevice device,
-                      const VkFramebufferCreateInfo *pCreateInfo,
-                      const VkAllocationCallbacks *pAllocator,
-                      VkFramebuffer *pFramebuffer) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer);
-  }
-
-  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
-  vkCreateHeadlessSurfaceEXT(VkInstance instance,
-                             const VkHeadlessSurfaceCreateInfoEXT *pCreateInfo,
-                             const VkAllocationCallbacks *pAllocator,
-                             VkSurfaceKHR *pSurface) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCreateHeadlessSurfaceEXT(instance, pCreateInfo, pAllocator,
-                                        pSurface);
-  }
-
-#if defined(VK_USE_PLATFORM_IOS_MVK)
-  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*/
-
-  VkResult vkCreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo,
-                         const VkAllocationCallbacks *pAllocator,
-                         VkImage *pImage) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCreateImage(device, pCreateInfo, pAllocator, pImage);
-  }
-
-#if defined(VK_USE_PLATFORM_FUCHSIA)
   VkResult vkCreateImagePipeSurfaceFUCHSIA(
       VkInstance instance,
       const VkImagePipeSurfaceCreateInfoFUCHSIA *pCreateInfo,
@@ -2635,40 +4211,10 @@
   }
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 
-  VkResult vkCreateImageView(VkDevice device,
-                             const VkImageViewCreateInfo *pCreateInfo,
-                             const VkAllocationCallbacks *pAllocator,
-                             VkImageView *pView) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCreateImageView(device, pCreateInfo, pAllocator, pView);
-  }
-
-  VkResult vkCreateIndirectCommandsLayoutNV(
-      VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV *pCreateInfo,
-      const VkAllocationCallbacks *pAllocator,
-      VkIndirectCommandsLayoutNV *pIndirectCommandsLayout) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkCreateIndirectCommandsLayoutNV(device, pCreateInfo, pAllocator,
-                                              pIndirectCommandsLayout);
-  }
-
-  VkResult vkCreateInstance(const VkInstanceCreateInfo *pCreateInfo,
-                            const VkAllocationCallbacks *pAllocator,
-                            VkInstance *pInstance) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCreateInstance(pCreateInfo, pAllocator, pInstance);
-  }
-
-#if defined(VK_USE_PLATFORM_MACOS_MVK)
-  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*/
-
 #if defined(VK_USE_PLATFORM_METAL_EXT)
+
+  //=== VK_EXT_metal_surface ===
+
   VkResult
   vkCreateMetalSurfaceEXT(VkInstance instance,
                           const VkMetalSurfaceCreateInfoEXT *pCreateInfo,
@@ -2679,642 +4225,25 @@
   }
 #endif /*VK_USE_PLATFORM_METAL_EXT*/
 
-  VkResult vkCreatePipelineCache(
-      VkDevice device, const VkPipelineCacheCreateInfo *pCreateInfo,
-      const VkAllocationCallbacks *pAllocator,
-      VkPipelineCache *pPipelineCache) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCreatePipelineCache(device, pCreateInfo, pAllocator,
-                                   pPipelineCache);
-  }
+  //=== VK_KHR_fragment_shading_rate ===
 
-  VkResult vkCreatePipelineLayout(
-      VkDevice device, const VkPipelineLayoutCreateInfo *pCreateInfo,
-      const VkAllocationCallbacks *pAllocator,
-      VkPipelineLayout *pPipelineLayout) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCreatePipelineLayout(device, pCreateInfo, pAllocator,
-                                    pPipelineLayout);
-  }
-
-  VkResult vkCreatePrivateDataSlotEXT(
-      VkDevice device, const VkPrivateDataSlotCreateInfoEXT *pCreateInfo,
-      const VkAllocationCallbacks *pAllocator,
-      VkPrivateDataSlotEXT *pPrivateDataSlot) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCreatePrivateDataSlotEXT(device, pCreateInfo, pAllocator,
-                                        pPrivateDataSlot);
-  }
-
-  VkResult
-  vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo *pCreateInfo,
-                    const VkAllocationCallbacks *pAllocator,
-                    VkQueryPool *pQueryPool) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool);
-  }
-
-  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 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
-  vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo *pCreateInfo,
-                     const VkAllocationCallbacks *pAllocator,
-                     VkRenderPass *pRenderPass) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
-  }
-
-  VkResult
-  vkCreateRenderPass2(VkDevice device,
-                      const VkRenderPassCreateInfo2 *pCreateInfo,
-                      const VkAllocationCallbacks *pAllocator,
-                      VkRenderPass *pRenderPass) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCreateRenderPass2(device, pCreateInfo, pAllocator, pRenderPass);
-  }
-
-  VkResult
-  vkCreateRenderPass2KHR(VkDevice device,
-                         const VkRenderPassCreateInfo2 *pCreateInfo,
-                         const VkAllocationCallbacks *pAllocator,
-                         VkRenderPass *pRenderPass) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCreateRenderPass2KHR(device, pCreateInfo, pAllocator,
-                                    pRenderPass);
-  }
-
-  VkResult vkCreateSampler(VkDevice device,
-                           const VkSamplerCreateInfo *pCreateInfo,
-                           const VkAllocationCallbacks *pAllocator,
-                           VkSampler *pSampler) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCreateSampler(device, pCreateInfo, pAllocator, pSampler);
-  }
-
-  VkResult vkCreateSamplerYcbcrConversion(
-      VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo,
-      const VkAllocationCallbacks *pAllocator,
-      VkSamplerYcbcrConversion *pYcbcrConversion) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCreateSamplerYcbcrConversion(device, pCreateInfo, pAllocator,
-                                            pYcbcrConversion);
-  }
-
-  VkResult vkCreateSamplerYcbcrConversionKHR(
-      VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo,
-      const VkAllocationCallbacks *pAllocator,
-      VkSamplerYcbcrConversion *pYcbcrConversion) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCreateSamplerYcbcrConversionKHR(device, pCreateInfo, pAllocator,
-                                               pYcbcrConversion);
-  }
-
-#if defined(VK_USE_PLATFORM_SCREEN_QNX)
-  VkResult
-  vkCreateScreenSurfaceQNX(VkInstance instance,
-                           const VkScreenSurfaceCreateInfoQNX *pCreateInfo,
-                           const VkAllocationCallbacks *pAllocator,
-                           VkSurfaceKHR *pSurface) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCreateScreenSurfaceQNX(instance, pCreateInfo, pAllocator,
-                                      pSurface);
-  }
-#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
-
-  VkResult
-  vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo *pCreateInfo,
-                    const VkAllocationCallbacks *pAllocator,
-                    VkSemaphore *pSemaphore) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore);
-  }
-
-  VkResult vkCreateShaderModule(
-      VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo,
-      const VkAllocationCallbacks *pAllocator,
-      VkShaderModule *pShaderModule) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCreateShaderModule(device, pCreateInfo, pAllocator,
-                                  pShaderModule);
-  }
-
-  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_GGP)
-  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*/
-
-  VkResult
-  vkCreateSwapchainKHR(VkDevice device,
-                       const VkSwapchainCreateInfoKHR *pCreateInfo,
-                       const VkAllocationCallbacks *pAllocator,
-                       VkSwapchainKHR *pSwapchain) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain);
-  }
-
-  VkResult vkCreateValidationCacheEXT(
-      VkDevice device, const VkValidationCacheCreateInfoEXT *pCreateInfo,
-      const VkAllocationCallbacks *pAllocator,
-      VkValidationCacheEXT *pValidationCache) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCreateValidationCacheEXT(device, pCreateInfo, pAllocator,
-                                        pValidationCache);
-  }
-
-#if defined(VK_USE_PLATFORM_VI_NN)
-  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*/
-
-#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
-  VkResult
-  vkCreateWaylandSurfaceKHR(VkInstance instance,
-                            const VkWaylandSurfaceCreateInfoKHR *pCreateInfo,
-                            const VkAllocationCallbacks *pAllocator,
-                            VkSurfaceKHR *pSurface) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCreateWaylandSurfaceKHR(instance, pCreateInfo, pAllocator,
-                                       pSurface);
-  }
-#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
-
-#if defined(VK_USE_PLATFORM_WIN32_KHR)
-  VkResult
-  vkCreateWin32SurfaceKHR(VkInstance instance,
-                          const VkWin32SurfaceCreateInfoKHR *pCreateInfo,
-                          const VkAllocationCallbacks *pAllocator,
-                          VkSurfaceKHR *pSurface) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCreateWin32SurfaceKHR(instance, pCreateInfo, pAllocator,
-                                     pSurface);
-  }
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#if defined(VK_USE_PLATFORM_XCB_KHR)
-  VkResult
-  vkCreateXcbSurfaceKHR(VkInstance instance,
-                        const VkXcbSurfaceCreateInfoKHR *pCreateInfo,
-                        const VkAllocationCallbacks *pAllocator,
-                        VkSurfaceKHR *pSurface) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCreateXcbSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
-  }
-#endif /*VK_USE_PLATFORM_XCB_KHR*/
-
-#if defined(VK_USE_PLATFORM_XLIB_KHR)
-  VkResult
-  vkCreateXlibSurfaceKHR(VkInstance instance,
-                         const VkXlibSurfaceCreateInfoKHR *pCreateInfo,
-                         const VkAllocationCallbacks *pAllocator,
-                         VkSurfaceKHR *pSurface) const VULKAN_HPP_NOEXCEPT {
-    return ::vkCreateXlibSurfaceKHR(instance, pCreateInfo, pAllocator,
-                                    pSurface);
-  }
-#endif /*VK_USE_PLATFORM_XLIB_KHR*/
-
-  VkResult vkDebugMarkerSetObjectNameEXT(
-      VkDevice device, const VkDebugMarkerObjectNameInfoEXT *pNameInfo) const
+  VkResult vkGetPhysicalDeviceFragmentShadingRatesKHR(
+      VkPhysicalDevice physicalDevice, uint32_t *pFragmentShadingRateCount,
+      VkPhysicalDeviceFragmentShadingRateKHR *pFragmentShadingRates) const
       VULKAN_HPP_NOEXCEPT {
-    return ::vkDebugMarkerSetObjectNameEXT(device, pNameInfo);
+    return ::vkGetPhysicalDeviceFragmentShadingRatesKHR(
+        physicalDevice, pFragmentShadingRateCount, pFragmentShadingRates);
   }
 
-  VkResult vkDebugMarkerSetObjectTagEXT(
-      VkDevice device,
-      const VkDebugMarkerObjectTagInfoEXT *pTagInfo) const VULKAN_HPP_NOEXCEPT {
-    return ::vkDebugMarkerSetObjectTagEXT(device, pTagInfo);
-  }
-
-  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);
-  }
-
-  VkResult vkDeferredOperationJoinKHR(VkDevice device,
-                                      VkDeferredOperationKHR operation) const
+  void vkCmdSetFragmentShadingRateKHR(
+      VkCommandBuffer commandBuffer, const VkExtent2D *pFragmentSize,
+      const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) const
       VULKAN_HPP_NOEXCEPT {
-    return ::vkDeferredOperationJoinKHR(device, operation);
+    return ::vkCmdSetFragmentShadingRateKHR(commandBuffer, pFragmentSize,
+                                            combinerOps);
   }
 
-  void vkDestroyAccelerationStructureKHR(
-      VkDevice device, VkAccelerationStructureKHR accelerationStructure,
-      const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT {
-    return ::vkDestroyAccelerationStructureKHR(device, accelerationStructure,
-                                               pAllocator);
-  }
-
-  void vkDestroyAccelerationStructureNV(
-      VkDevice device, VkAccelerationStructureNV accelerationStructure,
-      const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT {
-    return ::vkDestroyAccelerationStructureNV(device, accelerationStructure,
-                                              pAllocator);
-  }
-
-  void vkDestroyBuffer(VkDevice device, VkBuffer buffer,
-                       const VkAllocationCallbacks *pAllocator) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkDestroyBuffer(device, buffer, pAllocator);
-  }
-
-#if defined(VK_USE_PLATFORM_FUCHSIA)
-  void vkDestroyBufferCollectionFUCHSIA(
-      VkDevice device, VkBufferCollectionFUCHSIA collection,
-      const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT {
-    return ::vkDestroyBufferCollectionFUCHSIA(device, collection, pAllocator);
-  }
-#endif /*VK_USE_PLATFORM_FUCHSIA*/
-
-  void vkDestroyBufferView(VkDevice device, VkBufferView bufferView,
-                           const VkAllocationCallbacks *pAllocator) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkDestroyBufferView(device, bufferView, pAllocator);
-  }
-
-  void vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool,
-                            const VkAllocationCallbacks *pAllocator) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkDestroyCommandPool(device, commandPool, pAllocator);
-  }
-
-  void vkDestroyDebugReportCallbackEXT(
-      VkInstance instance, VkDebugReportCallbackEXT callback,
-      const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT {
-    return ::vkDestroyDebugReportCallbackEXT(instance, callback, pAllocator);
-  }
-
-  void vkDestroyDebugUtilsMessengerEXT(
-      VkInstance instance, VkDebugUtilsMessengerEXT messenger,
-      const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT {
-    return ::vkDestroyDebugUtilsMessengerEXT(instance, messenger, pAllocator);
-  }
-
-  void vkDestroyDeferredOperationKHR(
-      VkDevice device, VkDeferredOperationKHR operation,
-      const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT {
-    return ::vkDestroyDeferredOperationKHR(device, operation, pAllocator);
-  }
-
-  void vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
-                               const VkAllocationCallbacks *pAllocator) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkDestroyDescriptorPool(device, descriptorPool, pAllocator);
-  }
-
-  void vkDestroyDescriptorSetLayout(
-      VkDevice device, VkDescriptorSetLayout descriptorSetLayout,
-      const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT {
-    return ::vkDestroyDescriptorSetLayout(device, descriptorSetLayout,
-                                          pAllocator);
-  }
-
-  void vkDestroyDescriptorUpdateTemplate(
-      VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate,
-      const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT {
-    return ::vkDestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate,
-                                               pAllocator);
-  }
-
-  void vkDestroyDescriptorUpdateTemplateKHR(
-      VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate,
-      const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT {
-    return ::vkDestroyDescriptorUpdateTemplateKHR(
-        device, descriptorUpdateTemplate, pAllocator);
-  }
-
-  void vkDestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator)
-      const VULKAN_HPP_NOEXCEPT {
-    return ::vkDestroyDevice(device, pAllocator);
-  }
-
-  void vkDestroyEvent(VkDevice device, VkEvent event,
-                      const VkAllocationCallbacks *pAllocator) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkDestroyEvent(device, event, pAllocator);
-  }
-
-  void vkDestroyFence(VkDevice device, VkFence fence,
-                      const VkAllocationCallbacks *pAllocator) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkDestroyFence(device, fence, pAllocator);
-  }
-
-  void vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer,
-                            const VkAllocationCallbacks *pAllocator) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkDestroyFramebuffer(device, framebuffer, pAllocator);
-  }
-
-  void vkDestroyImage(VkDevice device, VkImage image,
-                      const VkAllocationCallbacks *pAllocator) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkDestroyImage(device, image, pAllocator);
-  }
-
-  void vkDestroyImageView(VkDevice device, VkImageView imageView,
-                          const VkAllocationCallbacks *pAllocator) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkDestroyImageView(device, imageView, pAllocator);
-  }
-
-  void vkDestroyIndirectCommandsLayoutNV(
-      VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout,
-      const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT {
-    return ::vkDestroyIndirectCommandsLayoutNV(device, indirectCommandsLayout,
-                                               pAllocator);
-  }
-
-  void vkDestroyInstance(VkInstance instance,
-                         const VkAllocationCallbacks *pAllocator) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkDestroyInstance(instance, pAllocator);
-  }
-
-  void vkDestroyPipeline(VkDevice device, VkPipeline pipeline,
-                         const VkAllocationCallbacks *pAllocator) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkDestroyPipeline(device, pipeline, pAllocator);
-  }
-
-  void vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache,
-                              const VkAllocationCallbacks *pAllocator) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkDestroyPipelineCache(device, pipelineCache, pAllocator);
-  }
-
-  void vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout,
-                               const VkAllocationCallbacks *pAllocator) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkDestroyPipelineLayout(device, pipelineLayout, pAllocator);
-  }
-
-  void vkDestroyPrivateDataSlotEXT(
-      VkDevice device, VkPrivateDataSlotEXT privateDataSlot,
-      const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT {
-    return ::vkDestroyPrivateDataSlotEXT(device, privateDataSlot, pAllocator);
-  }
-
-  void vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool,
-                          const VkAllocationCallbacks *pAllocator) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkDestroyQueryPool(device, queryPool, pAllocator);
-  }
-
-  void vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass,
-                           const VkAllocationCallbacks *pAllocator) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkDestroyRenderPass(device, renderPass, pAllocator);
-  }
-
-  void vkDestroySampler(VkDevice device, VkSampler sampler,
-                        const VkAllocationCallbacks *pAllocator) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkDestroySampler(device, sampler, pAllocator);
-  }
-
-  void vkDestroySamplerYcbcrConversion(
-      VkDevice device, VkSamplerYcbcrConversion ycbcrConversion,
-      const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT {
-    return ::vkDestroySamplerYcbcrConversion(device, ycbcrConversion,
-                                             pAllocator);
-  }
-
-  void vkDestroySamplerYcbcrConversionKHR(
-      VkDevice device, VkSamplerYcbcrConversion ycbcrConversion,
-      const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT {
-    return ::vkDestroySamplerYcbcrConversionKHR(device, ycbcrConversion,
-                                                pAllocator);
-  }
-
-  void vkDestroySemaphore(VkDevice device, VkSemaphore semaphore,
-                          const VkAllocationCallbacks *pAllocator) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkDestroySemaphore(device, semaphore, pAllocator);
-  }
-
-  void vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule,
-                             const VkAllocationCallbacks *pAllocator) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkDestroyShaderModule(device, shaderModule, pAllocator);
-  }
-
-  void vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface,
-                           const VkAllocationCallbacks *pAllocator) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkDestroySurfaceKHR(instance, surface, pAllocator);
-  }
-
-  void vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain,
-                             const VkAllocationCallbacks *pAllocator) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkDestroySwapchainKHR(device, swapchain, pAllocator);
-  }
-
-  void vkDestroyValidationCacheEXT(
-      VkDevice device, VkValidationCacheEXT validationCache,
-      const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT {
-    return ::vkDestroyValidationCacheEXT(device, validationCache, pAllocator);
-  }
-
-  VkResult vkDeviceWaitIdle(VkDevice device) const VULKAN_HPP_NOEXCEPT {
-    return ::vkDeviceWaitIdle(device);
-  }
-
-  VkResult
-  vkDisplayPowerControlEXT(VkDevice device, VkDisplayKHR display,
-                           const VkDisplayPowerInfoEXT *pDisplayPowerInfo) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkDisplayPowerControlEXT(device, display, pDisplayPowerInfo);
-  }
-
-  VkResult
-  vkEndCommandBuffer(VkCommandBuffer commandBuffer) const VULKAN_HPP_NOEXCEPT {
-    return ::vkEndCommandBuffer(commandBuffer);
-  }
-
-  VkResult vkEnumerateDeviceExtensionProperties(
-      VkPhysicalDevice physicalDevice, const char *pLayerName,
-      uint32_t *pPropertyCount,
-      VkExtensionProperties *pProperties) const VULKAN_HPP_NOEXCEPT {
-    return ::vkEnumerateDeviceExtensionProperties(physicalDevice, pLayerName,
-                                                  pPropertyCount, pProperties);
-  }
-
-  VkResult vkEnumerateDeviceLayerProperties(
-      VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount,
-      VkLayerProperties *pProperties) const VULKAN_HPP_NOEXCEPT {
-    return ::vkEnumerateDeviceLayerProperties(physicalDevice, pPropertyCount,
-                                              pProperties);
-  }
-
-  VkResult vkEnumerateInstanceExtensionProperties(
-      const char *pLayerName, uint32_t *pPropertyCount,
-      VkExtensionProperties *pProperties) const VULKAN_HPP_NOEXCEPT {
-    return ::vkEnumerateInstanceExtensionProperties(pLayerName, pPropertyCount,
-                                                    pProperties);
-  }
-
-  VkResult vkEnumerateInstanceLayerProperties(
-      uint32_t *pPropertyCount,
-      VkLayerProperties *pProperties) const VULKAN_HPP_NOEXCEPT {
-    return ::vkEnumerateInstanceLayerProperties(pPropertyCount, pProperties);
-  }
-
-  VkResult
-  vkEnumerateInstanceVersion(uint32_t *pApiVersion) const VULKAN_HPP_NOEXCEPT {
-    return ::vkEnumerateInstanceVersion(pApiVersion);
-  }
-
-  VkResult vkEnumeratePhysicalDeviceGroups(
-      VkInstance instance, uint32_t *pPhysicalDeviceGroupCount,
-      VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkEnumeratePhysicalDeviceGroups(
-        instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
-  }
-
-  VkResult vkEnumeratePhysicalDeviceGroupsKHR(
-      VkInstance instance, uint32_t *pPhysicalDeviceGroupCount,
-      VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkEnumeratePhysicalDeviceGroupsKHR(
-        instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
-  }
-
-  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);
-  }
-
-  VkResult vkEnumeratePhysicalDevices(
-      VkInstance instance, uint32_t *pPhysicalDeviceCount,
-      VkPhysicalDevice *pPhysicalDevices) const VULKAN_HPP_NOEXCEPT {
-    return ::vkEnumeratePhysicalDevices(instance, pPhysicalDeviceCount,
-                                        pPhysicalDevices);
-  }
-
-  VkResult vkFlushMappedMemoryRanges(
-      VkDevice device, uint32_t memoryRangeCount,
-      const VkMappedMemoryRange *pMemoryRanges) const VULKAN_HPP_NOEXCEPT {
-    return ::vkFlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
-  }
-
-  void vkFreeCommandBuffers(
-      VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount,
-      const VkCommandBuffer *pCommandBuffers) const VULKAN_HPP_NOEXCEPT {
-    return ::vkFreeCommandBuffers(device, commandPool, commandBufferCount,
-                                  pCommandBuffers);
-  }
-
-  VkResult vkFreeDescriptorSets(
-      VkDevice device, VkDescriptorPool descriptorPool,
-      uint32_t descriptorSetCount,
-      const VkDescriptorSet *pDescriptorSets) const VULKAN_HPP_NOEXCEPT {
-    return ::vkFreeDescriptorSets(device, descriptorPool, descriptorSetCount,
-                                  pDescriptorSets);
-  }
-
-  void vkFreeMemory(VkDevice device, VkDeviceMemory memory,
-                    const VkAllocationCallbacks *pAllocator) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkFreeMemory(device, memory, pAllocator);
-  }
-
-  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);
-  }
-
-  VkDeviceAddress vkGetAccelerationStructureDeviceAddressKHR(
-      VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR *pInfo)
-      const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetAccelerationStructureDeviceAddressKHR(device, pInfo);
-  }
-
-  VkResult vkGetAccelerationStructureHandleNV(
-      VkDevice device, VkAccelerationStructureNV accelerationStructure,
-      size_t dataSize, void *pData) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetAccelerationStructureHandleNV(device, accelerationStructure,
-                                                dataSize, pData);
-  }
-
-  void vkGetAccelerationStructureMemoryRequirementsNV(
-      VkDevice device,
-      const VkAccelerationStructureMemoryRequirementsInfoNV *pInfo,
-      VkMemoryRequirements2KHR *pMemoryRequirements) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetAccelerationStructureMemoryRequirementsNV(
-        device, pInfo, pMemoryRequirements);
-  }
-
-#if defined(VK_USE_PLATFORM_ANDROID_KHR)
-  VkResult vkGetAndroidHardwareBufferPropertiesANDROID(
-      VkDevice device, const struct AHardwareBuffer *buffer,
-      VkAndroidHardwareBufferPropertiesANDROID *pProperties) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkGetAndroidHardwareBufferPropertiesANDROID(device, buffer,
-                                                         pProperties);
-  }
-#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
-
-#if defined(VK_USE_PLATFORM_FUCHSIA)
-  VkResult vkGetBufferCollectionProperties2FUCHSIA(
-      VkDevice device, VkBufferCollectionFUCHSIA collection,
-      VkBufferCollectionProperties2FUCHSIA *pProperties) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkGetBufferCollectionProperties2FUCHSIA(device, collection,
-                                                     pProperties);
-  }
-#endif /*VK_USE_PLATFORM_FUCHSIA*/
-
-#if defined(VK_USE_PLATFORM_FUCHSIA)
-  VkResult vkGetBufferCollectionPropertiesFUCHSIA(
-      VkDevice device, VkBufferCollectionFUCHSIA collection,
-      VkBufferCollectionPropertiesFUCHSIA *pProperties) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkGetBufferCollectionPropertiesFUCHSIA(device, collection,
-                                                    pProperties);
-  }
-#endif /*VK_USE_PLATFORM_FUCHSIA*/
-
-  VkDeviceAddress vkGetBufferDeviceAddress(
-      VkDevice device,
-      const VkBufferDeviceAddressInfo *pInfo) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetBufferDeviceAddress(device, pInfo);
-  }
+  //=== VK_EXT_buffer_device_address ===
 
   VkDeviceAddress vkGetBufferDeviceAddressEXT(
       VkDevice device,
@@ -3322,50 +4251,208 @@
     return ::vkGetBufferDeviceAddressEXT(device, pInfo);
   }
 
+  //=== VK_EXT_tooling_info ===
+
+  VkResult vkGetPhysicalDeviceToolPropertiesEXT(
+      VkPhysicalDevice physicalDevice, uint32_t *pToolCount,
+      VkPhysicalDeviceToolPropertiesEXT *pToolProperties) const
+      VULKAN_HPP_NOEXCEPT {
+    return ::vkGetPhysicalDeviceToolPropertiesEXT(physicalDevice, pToolCount,
+                                                  pToolProperties);
+  }
+
+  //=== 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);
   }
 
-  void vkGetBufferMemoryRequirements(
-      VkDevice device, VkBuffer buffer,
-      VkMemoryRequirements *pMemoryRequirements) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
-  }
-
-  void vkGetBufferMemoryRequirements2(
-      VkDevice device, const VkBufferMemoryRequirementsInfo2 *pInfo,
-      VkMemoryRequirements2 *pMemoryRequirements) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetBufferMemoryRequirements2(device, pInfo, pMemoryRequirements);
-  }
-
-  void vkGetBufferMemoryRequirements2KHR(
-      VkDevice device, const VkBufferMemoryRequirementsInfo2 *pInfo,
-      VkMemoryRequirements2 *pMemoryRequirements) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetBufferMemoryRequirements2KHR(device, pInfo,
-                                               pMemoryRequirements);
-  }
-
-  uint64_t vkGetBufferOpaqueCaptureAddress(
-      VkDevice device,
-      const VkBufferDeviceAddressInfo *pInfo) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetBufferOpaqueCaptureAddress(device, pInfo);
-  }
-
   uint64_t vkGetBufferOpaqueCaptureAddressKHR(
       VkDevice device,
       const VkBufferDeviceAddressInfo *pInfo) const VULKAN_HPP_NOEXCEPT {
     return ::vkGetBufferOpaqueCaptureAddressKHR(device, pInfo);
   }
 
-  VkResult vkGetCalibratedTimestampsEXT(
-      VkDevice device, uint32_t timestampCount,
-      const VkCalibratedTimestampInfoEXT *pTimestampInfos,
-      uint64_t *pTimestamps,
-      uint64_t *pMaxDeviation) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetCalibratedTimestampsEXT(
-        device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation);
+  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(
@@ -3380,803 +4467,13 @@
     return ::vkGetDeferredOperationResultKHR(device, operation);
   }
 
-  void vkGetDescriptorSetLayoutSupport(
-      VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo,
-      VkDescriptorSetLayoutSupport *pSupport) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport);
-  }
-
-  void vkGetDescriptorSetLayoutSupportKHR(
-      VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo,
-      VkDescriptorSetLayoutSupport *pSupport) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetDescriptorSetLayoutSupportKHR(device, pCreateInfo, pSupport);
-  }
-
-  void vkGetDeviceAccelerationStructureCompatibilityKHR(
-      VkDevice device,
-      const VkAccelerationStructureVersionInfoKHR *pVersionInfo,
-      VkAccelerationStructureCompatibilityKHR *pCompatibility) const
+  VkResult vkDeferredOperationJoinKHR(VkDevice device,
+                                      VkDeferredOperationKHR operation) const
       VULKAN_HPP_NOEXCEPT {
-    return ::vkGetDeviceAccelerationStructureCompatibilityKHR(
-        device, pVersionInfo, pCompatibility);
+    return ::vkDeferredOperationJoinKHR(device, operation);
   }
 
-  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);
-  }
-
-  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);
-  }
-
-  VkResult vkGetDeviceGroupPresentCapabilitiesKHR(
-      VkDevice device,
-      VkDeviceGroupPresentCapabilitiesKHR *pDeviceGroupPresentCapabilities)
-      const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetDeviceGroupPresentCapabilitiesKHR(
-        device, pDeviceGroupPresentCapabilities);
-  }
-
-#if defined(VK_USE_PLATFORM_WIN32_KHR)
-  VkResult vkGetDeviceGroupSurfacePresentModes2EXT(
-      VkDevice device, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo,
-      VkDeviceGroupPresentModeFlagsKHR *pModes) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetDeviceGroupSurfacePresentModes2EXT(device, pSurfaceInfo,
-                                                     pModes);
-  }
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-  VkResult vkGetDeviceGroupSurfacePresentModesKHR(
-      VkDevice device, VkSurfaceKHR surface,
-      VkDeviceGroupPresentModeFlagsKHR *pModes) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetDeviceGroupSurfacePresentModesKHR(device, surface, pModes);
-  }
-
-  void vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory,
-                                   VkDeviceSize *pCommittedMemoryInBytes) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkGetDeviceMemoryCommitment(device, memory,
-                                         pCommittedMemoryInBytes);
-  }
-
-  uint64_t vkGetDeviceMemoryOpaqueCaptureAddress(
-      VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo *pInfo)
-      const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetDeviceMemoryOpaqueCaptureAddress(device, pInfo);
-  }
-
-  uint64_t vkGetDeviceMemoryOpaqueCaptureAddressKHR(
-      VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo *pInfo)
-      const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetDeviceMemoryOpaqueCaptureAddressKHR(device, pInfo);
-  }
-
-  PFN_vkVoidFunction
-  vkGetDeviceProcAddr(VkDevice device,
-                      const char *pName) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetDeviceProcAddr(device, pName);
-  }
-
-  void vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex,
-                        uint32_t queueIndex,
-                        VkQueue *pQueue) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue);
-  }
-
-  void vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2 *pQueueInfo,
-                         VkQueue *pQueue) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetDeviceQueue2(device, pQueueInfo, pQueue);
-  }
-
-  VkResult vkGetDisplayModeProperties2KHR(
-      VkPhysicalDevice physicalDevice, VkDisplayKHR display,
-      uint32_t *pPropertyCount,
-      VkDisplayModeProperties2KHR *pProperties) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetDisplayModeProperties2KHR(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 vkGetDisplayPlaneCapabilities2KHR(
-      VkPhysicalDevice physicalDevice,
-      const VkDisplayPlaneInfo2KHR *pDisplayPlaneInfo,
-      VkDisplayPlaneCapabilities2KHR *pCapabilities) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetDisplayPlaneCapabilities2KHR(
-        physicalDevice, pDisplayPlaneInfo, pCapabilities);
-  }
-
-  VkResult vkGetDisplayPlaneCapabilitiesKHR(
-      VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode,
-      uint32_t planeIndex,
-      VkDisplayPlaneCapabilitiesKHR *pCapabilities) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetDisplayPlaneCapabilitiesKHR(physicalDevice, mode, planeIndex,
-                                              pCapabilities);
-  }
-
-  VkResult vkGetDisplayPlaneSupportedDisplaysKHR(
-      VkPhysicalDevice physicalDevice, uint32_t planeIndex,
-      uint32_t *pDisplayCount,
-      VkDisplayKHR *pDisplays) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetDisplayPlaneSupportedDisplaysKHR(physicalDevice, planeIndex,
-                                                   pDisplayCount, pDisplays);
-  }
-
-  VkResult vkGetEventStatus(VkDevice device,
-                            VkEvent event) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetEventStatus(device, event);
-  }
-
-  VkResult vkGetFenceFdKHR(VkDevice device,
-                           const VkFenceGetFdInfoKHR *pGetFdInfo,
-                           int *pFd) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetFenceFdKHR(device, pGetFdInfo, pFd);
-  }
-
-  VkResult vkGetFenceStatus(VkDevice device,
-                            VkFence fence) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetFenceStatus(device, fence);
-  }
-
-#if defined(VK_USE_PLATFORM_WIN32_KHR)
-  VkResult vkGetFenceWin32HandleKHR(
-      VkDevice device, const VkFenceGetWin32HandleInfoKHR *pGetWin32HandleInfo,
-      HANDLE *pHandle) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetFenceWin32HandleKHR(device, pGetWin32HandleInfo, pHandle);
-  }
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-  void vkGetGeneratedCommandsMemoryRequirementsNV(
-      VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV *pInfo,
-      VkMemoryRequirements2 *pMemoryRequirements) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetGeneratedCommandsMemoryRequirementsNV(device, pInfo,
-                                                        pMemoryRequirements);
-  }
-
-  VkResult vkGetImageDrmFormatModifierPropertiesEXT(
-      VkDevice device, VkImage image,
-      VkImageDrmFormatModifierPropertiesEXT *pProperties) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkGetImageDrmFormatModifierPropertiesEXT(device, image,
-                                                      pProperties);
-  }
-
-  void vkGetImageMemoryRequirements(
-      VkDevice device, VkImage image,
-      VkMemoryRequirements *pMemoryRequirements) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetImageMemoryRequirements(device, image, pMemoryRequirements);
-  }
-
-  void vkGetImageMemoryRequirements2(
-      VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo,
-      VkMemoryRequirements2 *pMemoryRequirements) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetImageMemoryRequirements2(device, pInfo, pMemoryRequirements);
-  }
-
-  void vkGetImageMemoryRequirements2KHR(
-      VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo,
-      VkMemoryRequirements2 *pMemoryRequirements) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetImageMemoryRequirements2KHR(device, pInfo,
-                                              pMemoryRequirements);
-  }
-
-  void vkGetImageSparseMemoryRequirements(
-      VkDevice device, VkImage image, uint32_t *pSparseMemoryRequirementCount,
-      VkSparseImageMemoryRequirements *pSparseMemoryRequirements) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkGetImageSparseMemoryRequirements(device, image,
-                                                pSparseMemoryRequirementCount,
-                                                pSparseMemoryRequirements);
-  }
-
-  void vkGetImageSparseMemoryRequirements2(
-      VkDevice device, const VkImageSparseMemoryRequirementsInfo2 *pInfo,
-      uint32_t *pSparseMemoryRequirementCount,
-      VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkGetImageSparseMemoryRequirements2(device, pInfo,
-                                                 pSparseMemoryRequirementCount,
-                                                 pSparseMemoryRequirements);
-  }
-
-  void vkGetImageSparseMemoryRequirements2KHR(
-      VkDevice device, const VkImageSparseMemoryRequirementsInfo2 *pInfo,
-      uint32_t *pSparseMemoryRequirementCount,
-      VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkGetImageSparseMemoryRequirements2KHR(
-        device, pInfo, pSparseMemoryRequirementCount,
-        pSparseMemoryRequirements);
-  }
-
-  void vkGetImageSubresourceLayout(
-      VkDevice device, VkImage image, const VkImageSubresource *pSubresource,
-      VkSubresourceLayout *pLayout) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetImageSubresourceLayout(device, image, pSubresource, pLayout);
-  }
-
-  VkResult vkGetImageViewAddressNVX(
-      VkDevice device, VkImageView imageView,
-      VkImageViewAddressPropertiesNVX *pProperties) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetImageViewAddressNVX(device, imageView, pProperties);
-  }
-
-  uint32_t vkGetImageViewHandleNVX(VkDevice device,
-                                   const VkImageViewHandleInfoNVX *pInfo) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkGetImageViewHandleNVX(device, pInfo);
-  }
-
-  PFN_vkVoidFunction
-  vkGetInstanceProcAddr(VkInstance instance,
-                        const char *pName) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetInstanceProcAddr(instance, pName);
-  }
-
-#if defined(VK_USE_PLATFORM_ANDROID_KHR)
-  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*/
-
-  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);
-  }
-
-  VkResult vkGetMemoryHostPointerPropertiesEXT(
-      VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType,
-      const void *pHostPointer,
-      VkMemoryHostPointerPropertiesEXT *pMemoryHostPointerProperties) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkGetMemoryHostPointerPropertiesEXT(
-        device, handleType, pHostPointer, pMemoryHostPointerProperties);
-  }
-
-#if defined(VK_USE_PLATFORM_WIN32_KHR)
-  VkResult vkGetMemoryWin32HandleKHR(
-      VkDevice device, const VkMemoryGetWin32HandleInfoKHR *pGetWin32HandleInfo,
-      HANDLE *pHandle) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetMemoryWin32HandleKHR(device, pGetWin32HandleInfo, pHandle);
-  }
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#if defined(VK_USE_PLATFORM_WIN32_KHR)
-  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*/
-
-#if defined(VK_USE_PLATFORM_WIN32_KHR)
-  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*/
-
-#if defined(VK_USE_PLATFORM_FUCHSIA)
-  VkResult vkGetMemoryZirconHandleFUCHSIA(
-      VkDevice device,
-      const VkMemoryGetZirconHandleInfoFUCHSIA *pGetZirconHandleInfo,
-      zx_handle_t *pZirconHandle) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetMemoryZirconHandleFUCHSIA(device, pGetZirconHandleInfo,
-                                            pZirconHandle);
-  }
-#endif /*VK_USE_PLATFORM_FUCHSIA*/
-
-#if defined(VK_USE_PLATFORM_FUCHSIA)
-  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*/
-
-  VkResult vkGetPastPresentationTimingGOOGLE(
-      VkDevice device, VkSwapchainKHR swapchain,
-      uint32_t *pPresentationTimingCount,
-      VkPastPresentationTimingGOOGLE *pPresentationTimings) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkGetPastPresentationTimingGOOGLE(
-        device, swapchain, pPresentationTimingCount, pPresentationTimings);
-  }
-
-  VkResult vkGetPerformanceParameterINTEL(
-      VkDevice device, VkPerformanceParameterTypeINTEL parameter,
-      VkPerformanceValueINTEL *pValue) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetPerformanceParameterINTEL(device, parameter, pValue);
-  }
-
-  VkResult vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(
-      VkPhysicalDevice physicalDevice, uint32_t *pTimeDomainCount,
-      VkTimeDomainEXT *pTimeDomains) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(
-        physicalDevice, pTimeDomainCount, pTimeDomains);
-  }
-
-  VkResult vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(
-      VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount,
-      VkCooperativeMatrixPropertiesNV *pProperties) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(
-        physicalDevice, pPropertyCount, pProperties);
-  }
-
-#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
-  VkBool32 vkGetPhysicalDeviceDirectFBPresentationSupportEXT(
-      VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex,
-      IDirectFB *dfb) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetPhysicalDeviceDirectFBPresentationSupportEXT(
-        physicalDevice, queueFamilyIndex, dfb);
-  }
-#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
-
-  VkResult vkGetPhysicalDeviceDisplayPlaneProperties2KHR(
-      VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount,
-      VkDisplayPlaneProperties2KHR *pProperties) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetPhysicalDeviceDisplayPlaneProperties2KHR(
-        physicalDevice, pPropertyCount, pProperties);
-  }
-
-  VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
-      VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount,
-      VkDisplayPlanePropertiesKHR *pProperties) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
-        physicalDevice, pPropertyCount, pProperties);
-  }
-
-  VkResult vkGetPhysicalDeviceDisplayProperties2KHR(
-      VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount,
-      VkDisplayProperties2KHR *pProperties) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetPhysicalDeviceDisplayProperties2KHR(
-        physicalDevice, pPropertyCount, pProperties);
-  }
-
-  VkResult vkGetPhysicalDeviceDisplayPropertiesKHR(
-      VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount,
-      VkDisplayPropertiesKHR *pProperties) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetPhysicalDeviceDisplayPropertiesKHR(
-        physicalDevice, pPropertyCount, pProperties);
-  }
-
-  void vkGetPhysicalDeviceExternalBufferProperties(
-      VkPhysicalDevice physicalDevice,
-      const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo,
-      VkExternalBufferProperties *pExternalBufferProperties) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkGetPhysicalDeviceExternalBufferProperties(
-        physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
-  }
-
-  void vkGetPhysicalDeviceExternalBufferPropertiesKHR(
-      VkPhysicalDevice physicalDevice,
-      const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo,
-      VkExternalBufferProperties *pExternalBufferProperties) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkGetPhysicalDeviceExternalBufferPropertiesKHR(
-        physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
-  }
-
-  void vkGetPhysicalDeviceExternalFenceProperties(
-      VkPhysicalDevice physicalDevice,
-      const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo,
-      VkExternalFenceProperties *pExternalFenceProperties) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkGetPhysicalDeviceExternalFenceProperties(
-        physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
-  }
-
-  void vkGetPhysicalDeviceExternalFencePropertiesKHR(
-      VkPhysicalDevice physicalDevice,
-      const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo,
-      VkExternalFenceProperties *pExternalFenceProperties) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkGetPhysicalDeviceExternalFencePropertiesKHR(
-        physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
-  }
-
-  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);
-  }
-
-  void vkGetPhysicalDeviceExternalSemaphoreProperties(
-      VkPhysicalDevice physicalDevice,
-      const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo,
-      VkExternalSemaphoreProperties *pExternalSemaphoreProperties) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkGetPhysicalDeviceExternalSemaphoreProperties(
-        physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
-  }
-
-  void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
-      VkPhysicalDevice physicalDevice,
-      const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo,
-      VkExternalSemaphoreProperties *pExternalSemaphoreProperties) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
-        physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
-  }
-
-  void vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice,
-                                   VkPhysicalDeviceFeatures *pFeatures) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkGetPhysicalDeviceFeatures(physicalDevice, pFeatures);
-  }
-
-  void vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice,
-                                    VkPhysicalDeviceFeatures2 *pFeatures) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkGetPhysicalDeviceFeatures2(physicalDevice, pFeatures);
-  }
-
-  void vkGetPhysicalDeviceFeatures2KHR(
-      VkPhysicalDevice physicalDevice,
-      VkPhysicalDeviceFeatures2 *pFeatures) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetPhysicalDeviceFeatures2KHR(physicalDevice, pFeatures);
-  }
-
-  void vkGetPhysicalDeviceFormatProperties(
-      VkPhysicalDevice physicalDevice, VkFormat format,
-      VkFormatProperties *pFormatProperties) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetPhysicalDeviceFormatProperties(physicalDevice, format,
-                                                 pFormatProperties);
-  }
-
-  void vkGetPhysicalDeviceFormatProperties2(
-      VkPhysicalDevice physicalDevice, VkFormat format,
-      VkFormatProperties2 *pFormatProperties) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetPhysicalDeviceFormatProperties2(physicalDevice, format,
-                                                  pFormatProperties);
-  }
-
-  void vkGetPhysicalDeviceFormatProperties2KHR(
-      VkPhysicalDevice physicalDevice, VkFormat format,
-      VkFormatProperties2 *pFormatProperties) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetPhysicalDeviceFormatProperties2KHR(physicalDevice, format,
-                                                     pFormatProperties);
-  }
-
-  VkResult vkGetPhysicalDeviceFragmentShadingRatesKHR(
-      VkPhysicalDevice physicalDevice, uint32_t *pFragmentShadingRateCount,
-      VkPhysicalDeviceFragmentShadingRateKHR *pFragmentShadingRates) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkGetPhysicalDeviceFragmentShadingRatesKHR(
-        physicalDevice, pFragmentShadingRateCount, pFragmentShadingRates);
-  }
-
-  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);
-  }
-
-  VkResult vkGetPhysicalDeviceImageFormatProperties2(
-      VkPhysicalDevice physicalDevice,
-      const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo,
-      VkImageFormatProperties2 *pImageFormatProperties) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkGetPhysicalDeviceImageFormatProperties2(
-        physicalDevice, pImageFormatInfo, pImageFormatProperties);
-  }
-
-  VkResult vkGetPhysicalDeviceImageFormatProperties2KHR(
-      VkPhysicalDevice physicalDevice,
-      const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo,
-      VkImageFormatProperties2 *pImageFormatProperties) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkGetPhysicalDeviceImageFormatProperties2KHR(
-        physicalDevice, pImageFormatInfo, pImageFormatProperties);
-  }
-
-  void vkGetPhysicalDeviceMemoryProperties(
-      VkPhysicalDevice physicalDevice,
-      VkPhysicalDeviceMemoryProperties *pMemoryProperties) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkGetPhysicalDeviceMemoryProperties(physicalDevice,
-                                                 pMemoryProperties);
-  }
-
-  void vkGetPhysicalDeviceMemoryProperties2(
-      VkPhysicalDevice physicalDevice,
-      VkPhysicalDeviceMemoryProperties2 *pMemoryProperties) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkGetPhysicalDeviceMemoryProperties2(physicalDevice,
-                                                  pMemoryProperties);
-  }
-
-  void vkGetPhysicalDeviceMemoryProperties2KHR(
-      VkPhysicalDevice physicalDevice,
-      VkPhysicalDeviceMemoryProperties2 *pMemoryProperties) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkGetPhysicalDeviceMemoryProperties2KHR(physicalDevice,
-                                                     pMemoryProperties);
-  }
-
-  void vkGetPhysicalDeviceMultisamplePropertiesEXT(
-      VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples,
-      VkMultisamplePropertiesEXT *pMultisampleProperties) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkGetPhysicalDeviceMultisamplePropertiesEXT(
-        physicalDevice, samples, pMultisampleProperties);
-  }
-
-  VkResult vkGetPhysicalDevicePresentRectanglesKHR(
-      VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
-      uint32_t *pRectCount, VkRect2D *pRects) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetPhysicalDevicePresentRectanglesKHR(physicalDevice, surface,
-                                                     pRectCount, pRects);
-  }
-
-  void vkGetPhysicalDeviceProperties(
-      VkPhysicalDevice physicalDevice,
-      VkPhysicalDeviceProperties *pProperties) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetPhysicalDeviceProperties(physicalDevice, pProperties);
-  }
-
-  void vkGetPhysicalDeviceProperties2(
-      VkPhysicalDevice physicalDevice,
-      VkPhysicalDeviceProperties2 *pProperties) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetPhysicalDeviceProperties2(physicalDevice, pProperties);
-  }
-
-  void vkGetPhysicalDeviceProperties2KHR(
-      VkPhysicalDevice physicalDevice,
-      VkPhysicalDeviceProperties2 *pProperties) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetPhysicalDeviceProperties2KHR(physicalDevice, pProperties);
-  }
-
-  void vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(
-      VkPhysicalDevice physicalDevice,
-      const VkQueryPoolPerformanceCreateInfoKHR *pPerformanceQueryCreateInfo,
-      uint32_t *pNumPasses) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(
-        physicalDevice, pPerformanceQueryCreateInfo, pNumPasses);
-  }
-
-  void vkGetPhysicalDeviceQueueFamilyProperties(
-      VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount,
-      VkQueueFamilyProperties *pQueueFamilyProperties) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkGetPhysicalDeviceQueueFamilyProperties(
-        physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
-  }
-
-  void vkGetPhysicalDeviceQueueFamilyProperties2(
-      VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount,
-      VkQueueFamilyProperties2 *pQueueFamilyProperties) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkGetPhysicalDeviceQueueFamilyProperties2(
-        physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
-  }
-
-  void vkGetPhysicalDeviceQueueFamilyProperties2KHR(
-      VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount,
-      VkQueueFamilyProperties2 *pQueueFamilyProperties) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkGetPhysicalDeviceQueueFamilyProperties2KHR(
-        physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
-  }
-
-#if defined(VK_USE_PLATFORM_SCREEN_QNX)
-  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*/
-
-  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 vkGetPhysicalDeviceSparseImageFormatProperties2(
-      VkPhysicalDevice physicalDevice,
-      const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo,
-      uint32_t *pPropertyCount,
-      VkSparseImageFormatProperties2 *pProperties) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetPhysicalDeviceSparseImageFormatProperties2(
-        physicalDevice, pFormatInfo, pPropertyCount, pProperties);
-  }
-
-  void vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
-      VkPhysicalDevice physicalDevice,
-      const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo,
-      uint32_t *pPropertyCount,
-      VkSparseImageFormatProperties2 *pProperties) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
-        physicalDevice, pFormatInfo, pPropertyCount, pProperties);
-  }
-
-  VkResult vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
-      VkPhysicalDevice physicalDevice, uint32_t *pCombinationCount,
-      VkFramebufferMixedSamplesCombinationNV *pCombinations) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
-        physicalDevice, pCombinationCount, pCombinations);
-  }
-
-  VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT(
-      VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
-      VkSurfaceCapabilities2EXT *pSurfaceCapabilities) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkGetPhysicalDeviceSurfaceCapabilities2EXT(physicalDevice, surface,
-                                                        pSurfaceCapabilities);
-  }
-
-  VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR(
-      VkPhysicalDevice physicalDevice,
-      const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo,
-      VkSurfaceCapabilities2KHR *pSurfaceCapabilities) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkGetPhysicalDeviceSurfaceCapabilities2KHR(
-        physicalDevice, pSurfaceInfo, pSurfaceCapabilities);
-  }
-
-  VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
-      VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
-      VkSurfaceCapabilitiesKHR *pSurfaceCapabilities) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface,
-                                                       pSurfaceCapabilities);
-  }
-
-  VkResult vkGetPhysicalDeviceSurfaceFormats2KHR(
-      VkPhysicalDevice physicalDevice,
-      const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo,
-      uint32_t *pSurfaceFormatCount,
-      VkSurfaceFormat2KHR *pSurfaceFormats) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetPhysicalDeviceSurfaceFormats2KHR(
-        physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats);
-  }
-
-  VkResult vkGetPhysicalDeviceSurfaceFormatsKHR(
-      VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
-      uint32_t *pSurfaceFormatCount,
-      VkSurfaceFormatKHR *pSurfaceFormats) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetPhysicalDeviceSurfaceFormatsKHR(
-        physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats);
-  }
-
-#if defined(VK_USE_PLATFORM_WIN32_KHR)
-  VkResult vkGetPhysicalDeviceSurfacePresentModes2EXT(
-      VkPhysicalDevice physicalDevice,
-      const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo,
-      uint32_t *pPresentModeCount,
-      VkPresentModeKHR *pPresentModes) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetPhysicalDeviceSurfacePresentModes2EXT(
-        physicalDevice, pSurfaceInfo, pPresentModeCount, pPresentModes);
-  }
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-  VkResult vkGetPhysicalDeviceSurfacePresentModesKHR(
-      VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
-      uint32_t *pPresentModeCount,
-      VkPresentModeKHR *pPresentModes) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetPhysicalDeviceSurfacePresentModesKHR(
-        physicalDevice, surface, pPresentModeCount, pPresentModes);
-  }
-
-  VkResult vkGetPhysicalDeviceSurfaceSupportKHR(
-      VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex,
-      VkSurfaceKHR surface, VkBool32 *pSupported) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetPhysicalDeviceSurfaceSupportKHR(
-        physicalDevice, queueFamilyIndex, surface, pSupported);
-  }
-
-  VkResult vkGetPhysicalDeviceToolPropertiesEXT(
-      VkPhysicalDevice physicalDevice, uint32_t *pToolCount,
-      VkPhysicalDeviceToolPropertiesEXT *pToolProperties) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkGetPhysicalDeviceToolPropertiesEXT(physicalDevice, pToolCount,
-                                                  pToolProperties);
-  }
-
-#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
-  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_WIN32_KHR)
-  VkBool32 vkGetPhysicalDeviceWin32PresentationSupportKHR(
-      VkPhysicalDevice physicalDevice,
-      uint32_t queueFamilyIndex) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetPhysicalDeviceWin32PresentationSupportKHR(physicalDevice,
-                                                            queueFamilyIndex);
-  }
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#if defined(VK_USE_PLATFORM_XCB_KHR)
-  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_XLIB_KHR)
-  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*/
-
-  VkResult vkGetPipelineCacheData(VkDevice device,
-                                  VkPipelineCache pipelineCache,
-                                  size_t *pDataSize,
-                                  void *pData) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetPipelineCacheData(device, pipelineCache, pDataSize, pData);
-  }
-
-  VkResult vkGetPipelineExecutableInternalRepresentationsKHR(
-      VkDevice device, const VkPipelineExecutableInfoKHR *pExecutableInfo,
-      uint32_t *pInternalRepresentationCount,
-      VkPipelineExecutableInternalRepresentationKHR *pInternalRepresentations)
-      const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetPipelineExecutableInternalRepresentationsKHR(
-        device, pExecutableInfo, pInternalRepresentationCount,
-        pInternalRepresentations);
-  }
+  //=== VK_KHR_pipeline_executable_properties ===
 
   VkResult vkGetPipelineExecutablePropertiesKHR(
       VkDevice device, const VkPipelineInfoKHR *pPipelineInfo,
@@ -4195,6 +4492,88 @@
                                                   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_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_private_data ===
+
+  VkResult vkCreatePrivateDataSlotEXT(
+      VkDevice device, const VkPrivateDataSlotCreateInfoEXT *pCreateInfo,
+      const VkAllocationCallbacks *pAllocator,
+      VkPrivateDataSlotEXT *pPrivateDataSlot) const VULKAN_HPP_NOEXCEPT {
+    return ::vkCreatePrivateDataSlotEXT(device, pCreateInfo, pAllocator,
+                                        pPrivateDataSlot);
+  }
+
+  void vkDestroyPrivateDataSlotEXT(
+      VkDevice device, VkPrivateDataSlotEXT privateDataSlot,
+      const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT {
+    return ::vkDestroyPrivateDataSlotEXT(device, privateDataSlot, pAllocator);
+  }
+
+  VkResult vkSetPrivateDataEXT(VkDevice device, VkObjectType objectType,
+                               uint64_t objectHandle,
+                               VkPrivateDataSlotEXT privateDataSlot,
+                               uint64_t data) const VULKAN_HPP_NOEXCEPT {
+    return ::vkSetPrivateDataEXT(device, objectType, objectHandle,
+                                 privateDataSlot, data);
+  }
+
   void vkGetPrivateDataEXT(VkDevice device, VkObjectType objectType,
                            uint64_t objectHandle,
                            VkPrivateDataSlotEXT privateDataSlot,
@@ -4203,13 +4582,53 @@
                                  privateDataSlot, pData);
   }
 
-  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);
+  //=== VK_KHR_synchronization2 ===
+
+  void vkCmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event,
+                         const VkDependencyInfoKHR *pDependencyInfo) const
+      VULKAN_HPP_NOEXCEPT {
+    return ::vkCmdSetEvent2KHR(commandBuffer, event, pDependencyInfo);
+  }
+
+  void vkCmdResetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event,
+                           VkPipelineStageFlags2KHR stageMask) const
+      VULKAN_HPP_NOEXCEPT {
+    return ::vkCmdResetEvent2KHR(commandBuffer, event, stageMask);
+  }
+
+  void vkCmdWaitEvents2KHR(VkCommandBuffer commandBuffer, uint32_t eventCount,
+                           const VkEvent *pEvents,
+                           const VkDependencyInfoKHR *pDependencyInfos) const
+      VULKAN_HPP_NOEXCEPT {
+    return ::vkCmdWaitEvents2KHR(commandBuffer, eventCount, pEvents,
+                                 pDependencyInfos);
+  }
+
+  void vkCmdPipelineBarrier2KHR(
+      VkCommandBuffer commandBuffer,
+      const VkDependencyInfoKHR *pDependencyInfo) const VULKAN_HPP_NOEXCEPT {
+    return ::vkCmdPipelineBarrier2KHR(commandBuffer, pDependencyInfo);
+  }
+
+  void vkCmdWriteTimestamp2KHR(VkCommandBuffer commandBuffer,
+                               VkPipelineStageFlags2KHR stage,
+                               VkQueryPool queryPool,
+                               uint32_t query) const VULKAN_HPP_NOEXCEPT {
+    return ::vkCmdWriteTimestamp2KHR(commandBuffer, stage, queryPool, query);
+  }
+
+  VkResult vkQueueSubmit2KHR(VkQueue queue, uint32_t submitCount,
+                             const VkSubmitInfo2KHR *pSubmits,
+                             VkFence fence) const VULKAN_HPP_NOEXCEPT {
+    return ::vkQueueSubmit2KHR(queue, submitCount, pSubmits, fence);
+  }
+
+  void vkCmdWriteBufferMarker2AMD(VkCommandBuffer commandBuffer,
+                                  VkPipelineStageFlags2KHR stage,
+                                  VkBuffer dstBuffer, VkDeviceSize dstOffset,
+                                  uint32_t marker) const VULKAN_HPP_NOEXCEPT {
+    return ::vkCmdWriteBufferMarker2AMD(commandBuffer, stage, dstBuffer,
+                                        dstOffset, marker);
   }
 
   void vkGetQueueCheckpointData2NV(
@@ -4219,29 +4638,120 @@
                                          pCheckpointData);
   }
 
-  void vkGetQueueCheckpointDataNV(VkQueue queue, uint32_t *pCheckpointDataCount,
-                                  VkCheckpointDataNV *pCheckpointData) const
+  //=== VK_NV_fragment_shading_rate_enums ===
+
+  void vkCmdSetFragmentShadingRateEnumNV(
+      VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate,
+      const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) const
       VULKAN_HPP_NOEXCEPT {
-    return ::vkGetQueueCheckpointDataNV(queue, pCheckpointDataCount,
-                                        pCheckpointData);
+    return ::vkCmdSetFragmentShadingRateEnumNV(commandBuffer, shadingRate,
+                                               combinerOps);
   }
 
-#if defined(VK_USE_PLATFORM_XLIB_XRANDR_EXT)
+  //=== VK_KHR_copy_commands2 ===
+
+  void vkCmdCopyBuffer2KHR(VkCommandBuffer commandBuffer,
+                           const VkCopyBufferInfo2KHR *pCopyBufferInfo) const
+      VULKAN_HPP_NOEXCEPT {
+    return ::vkCmdCopyBuffer2KHR(commandBuffer, pCopyBufferInfo);
+  }
+
+  void vkCmdCopyImage2KHR(VkCommandBuffer commandBuffer,
+                          const VkCopyImageInfo2KHR *pCopyImageInfo) const
+      VULKAN_HPP_NOEXCEPT {
+    return ::vkCmdCopyImage2KHR(commandBuffer, pCopyImageInfo);
+  }
+
+  void vkCmdCopyBufferToImage2KHR(
+      VkCommandBuffer commandBuffer,
+      const VkCopyBufferToImageInfo2KHR *pCopyBufferToImageInfo) const
+      VULKAN_HPP_NOEXCEPT {
+    return ::vkCmdCopyBufferToImage2KHR(commandBuffer, pCopyBufferToImageInfo);
+  }
+
+  void vkCmdCopyImageToBuffer2KHR(
+      VkCommandBuffer commandBuffer,
+      const VkCopyImageToBufferInfo2KHR *pCopyImageToBufferInfo) const
+      VULKAN_HPP_NOEXCEPT {
+    return ::vkCmdCopyImageToBuffer2KHR(commandBuffer, pCopyImageToBufferInfo);
+  }
+
+  void vkCmdBlitImage2KHR(VkCommandBuffer commandBuffer,
+                          const VkBlitImageInfo2KHR *pBlitImageInfo) const
+      VULKAN_HPP_NOEXCEPT {
+    return ::vkCmdBlitImage2KHR(commandBuffer, pBlitImageInfo);
+  }
+
+  void vkCmdResolveImage2KHR(VkCommandBuffer commandBuffer,
+                             const VkResolveImageInfo2KHR *pResolveImageInfo)
+      const VULKAN_HPP_NOEXCEPT {
+    return ::vkCmdResolveImage2KHR(commandBuffer, pResolveImageInfo);
+  }
+
+#if defined(VK_USE_PLATFORM_WIN32_KHR)
+
+  //=== VK_NV_acquire_winrt_display ===
+
   VkResult
-  vkGetRandROutputDisplayEXT(VkPhysicalDevice physicalDevice, Display *dpy,
-                             RROutput rrOutput,
-                             VkDisplayKHR *pDisplay) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetRandROutputDisplayEXT(physicalDevice, dpy, rrOutput,
-                                        pDisplay);
+  vkAcquireWinrtDisplayNV(VkPhysicalDevice physicalDevice,
+                          VkDisplayKHR display) const VULKAN_HPP_NOEXCEPT {
+    return ::vkAcquireWinrtDisplayNV(physicalDevice, display);
   }
-#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
 
-  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);
+  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 ===
+
+  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);
+  }
+#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
+
+  //=== 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
@@ -4253,13 +4763,25 @@
                                                   groupCount, dataSize, pData);
   }
 
-  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 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(
@@ -4269,180 +4791,17 @@
                                                     groupShader);
   }
 
-  VkResult vkGetRefreshCycleDurationGOOGLE(
-      VkDevice device, VkSwapchainKHR swapchain,
-      VkRefreshCycleDurationGOOGLE *pDisplayTimingProperties) const
+  void vkCmdSetRayTracingPipelineStackSizeKHR(VkCommandBuffer commandBuffer,
+                                              uint32_t pipelineStackSize) const
       VULKAN_HPP_NOEXCEPT {
-    return ::vkGetRefreshCycleDurationGOOGLE(device, swapchain,
-                                             pDisplayTimingProperties);
-  }
-
-  void vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass,
-                                  VkExtent2D *pGranularity) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkGetRenderAreaGranularity(device, renderPass, pGranularity);
-  }
-
-  VkResult
-  vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore,
-                             uint64_t *pValue) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetSemaphoreCounterValue(device, semaphore, pValue);
-  }
-
-  VkResult
-  vkGetSemaphoreCounterValueKHR(VkDevice device, VkSemaphore semaphore,
-                                uint64_t *pValue) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetSemaphoreCounterValueKHR(device, semaphore, pValue);
-  }
-
-  VkResult vkGetSemaphoreFdKHR(VkDevice device,
-                               const VkSemaphoreGetFdInfoKHR *pGetFdInfo,
-                               int *pFd) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetSemaphoreFdKHR(device, pGetFdInfo, pFd);
-  }
-
-#if defined(VK_USE_PLATFORM_WIN32_KHR)
-  VkResult vkGetSemaphoreWin32HandleKHR(
-      VkDevice device,
-      const VkSemaphoreGetWin32HandleInfoKHR *pGetWin32HandleInfo,
-      HANDLE *pHandle) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetSemaphoreWin32HandleKHR(device, pGetWin32HandleInfo, pHandle);
-  }
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#if defined(VK_USE_PLATFORM_FUCHSIA)
-  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*/
-
-  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);
-  }
-
-  VkResult
-  vkGetSwapchainCounterEXT(VkDevice device, VkSwapchainKHR swapchain,
-                           VkSurfaceCounterFlagBitsEXT counter,
-                           uint64_t *pCounterValue) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetSwapchainCounterEXT(device, swapchain, counter,
-                                      pCounterValue);
-  }
-
-  VkResult
-  vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain,
-                          uint32_t *pSwapchainImageCount,
-                          VkImage *pSwapchainImages) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount,
-                                     pSwapchainImages);
-  }
-
-  VkResult
-  vkGetSwapchainStatusKHR(VkDevice device,
-                          VkSwapchainKHR swapchain) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetSwapchainStatusKHR(device, swapchain);
-  }
-
-  VkResult vkGetValidationCacheDataEXT(VkDevice device,
-                                       VkValidationCacheEXT validationCache,
-                                       size_t *pDataSize,
-                                       void *pData) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetValidationCacheDataEXT(device, validationCache, pDataSize,
-                                         pData);
-  }
-
-#if defined(VK_USE_PLATFORM_WIN32_KHR)
-  VkResult
-  vkGetWinrtDisplayNV(VkPhysicalDevice physicalDevice,
-                      uint32_t deviceRelativeId,
-                      VkDisplayKHR *pDisplay) const VULKAN_HPP_NOEXCEPT {
-    return ::vkGetWinrtDisplayNV(physicalDevice, deviceRelativeId, pDisplay);
-  }
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-  VkResult vkImportFenceFdKHR(VkDevice device,
-                              const VkImportFenceFdInfoKHR *pImportFenceFdInfo)
-      const VULKAN_HPP_NOEXCEPT {
-    return ::vkImportFenceFdKHR(device, pImportFenceFdInfo);
-  }
-
-#if defined(VK_USE_PLATFORM_WIN32_KHR)
-  VkResult vkImportFenceWin32HandleKHR(
-      VkDevice device,
-      const VkImportFenceWin32HandleInfoKHR *pImportFenceWin32HandleInfo) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkImportFenceWin32HandleKHR(device, pImportFenceWin32HandleInfo);
-  }
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-  VkResult vkImportSemaphoreFdKHR(
-      VkDevice device, const VkImportSemaphoreFdInfoKHR *pImportSemaphoreFdInfo)
-      const VULKAN_HPP_NOEXCEPT {
-    return ::vkImportSemaphoreFdKHR(device, pImportSemaphoreFdInfo);
-  }
-
-#if defined(VK_USE_PLATFORM_WIN32_KHR)
-  VkResult vkImportSemaphoreWin32HandleKHR(
-      VkDevice device,
-      const VkImportSemaphoreWin32HandleInfoKHR
-          *pImportSemaphoreWin32HandleInfo) const VULKAN_HPP_NOEXCEPT {
-    return ::vkImportSemaphoreWin32HandleKHR(device,
-                                             pImportSemaphoreWin32HandleInfo);
-  }
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#if defined(VK_USE_PLATFORM_FUCHSIA)
-  VkResult vkImportSemaphoreZirconHandleFUCHSIA(
-      VkDevice device,
-      const VkImportSemaphoreZirconHandleInfoFUCHSIA
-          *pImportSemaphoreZirconHandleInfo) const VULKAN_HPP_NOEXCEPT {
-    return ::vkImportSemaphoreZirconHandleFUCHSIA(
-        device, pImportSemaphoreZirconHandleInfo);
-  }
-#endif /*VK_USE_PLATFORM_FUCHSIA*/
-
-  VkResult vkInitializePerformanceApiINTEL(
-      VkDevice device,
-      const VkInitializePerformanceApiInfoINTEL *pInitializeInfo) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkInitializePerformanceApiINTEL(device, pInitializeInfo);
-  }
-
-  VkResult vkInvalidateMappedMemoryRanges(
-      VkDevice device, uint32_t memoryRangeCount,
-      const VkMappedMemoryRange *pMemoryRanges) const VULKAN_HPP_NOEXCEPT {
-    return ::vkInvalidateMappedMemoryRanges(device, memoryRangeCount,
-                                            pMemoryRanges);
-  }
-
-  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 vkMergePipelineCaches(
-      VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount,
-      const VkPipelineCache *pSrcCaches) const VULKAN_HPP_NOEXCEPT {
-    return ::vkMergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches);
-  }
-
-  VkResult vkMergeValidationCachesEXT(
-      VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount,
-      const VkValidationCacheEXT *pSrcCaches) const VULKAN_HPP_NOEXCEPT {
-    return ::vkMergeValidationCachesEXT(device, dstCache, srcCacheCount,
-                                        pSrcCaches);
+    return ::vkCmdSetRayTracingPipelineStackSizeKHR(commandBuffer,
+                                                    pipelineStackSize);
   }
 
 #if defined(VK_USE_PLATFORM_FUCHSIA)
+
+  //=== VK_FUCHSIA_memory_control ===
+
   VkResult vkModifyMemoryRangesFUCHSIA(
       VkDevice device, VkMemoryOpFlagsFUCHSIA op, uint32_t memoryRangeCount,
       const VkMemoryRangeFUCHSIA *pMemoryRanges,
@@ -4452,156 +4811,147 @@
   }
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 
-  void vkQueueBeginDebugUtilsLabelEXT(
-      VkQueue queue,
-      const VkDebugUtilsLabelEXT *pLabelInfo) const VULKAN_HPP_NOEXCEPT {
-    return ::vkQueueBeginDebugUtilsLabelEXT(queue, pLabelInfo);
-  }
-
-  VkResult vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount,
-                             const VkBindSparseInfo *pBindInfo,
-                             VkFence fence) const VULKAN_HPP_NOEXCEPT {
-    return ::vkQueueBindSparse(queue, bindInfoCount, pBindInfo, fence);
-  }
-
-  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);
-  }
-
-  VkResult vkQueuePresentKHR(VkQueue queue,
-                             const VkPresentInfoKHR *pPresentInfo) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkQueuePresentKHR(queue, pPresentInfo);
-  }
-
-  VkResult vkQueueSetPerformanceConfigurationINTEL(
-      VkQueue queue,
-      VkPerformanceConfigurationINTEL configuration) const VULKAN_HPP_NOEXCEPT {
-    return ::vkQueueSetPerformanceConfigurationINTEL(queue, configuration);
-  }
-
-  VkResult vkQueueSubmit(VkQueue queue, uint32_t submitCount,
-                         const VkSubmitInfo *pSubmits,
-                         VkFence fence) const VULKAN_HPP_NOEXCEPT {
-    return ::vkQueueSubmit(queue, submitCount, pSubmits, fence);
-  }
-
-  VkResult vkQueueSubmit2KHR(VkQueue queue, uint32_t submitCount,
-                             const VkSubmitInfo2KHR *pSubmits,
-                             VkFence fence) const VULKAN_HPP_NOEXCEPT {
-    return ::vkQueueSubmit2KHR(queue, submitCount, pSubmits, fence);
-  }
-
-  VkResult vkQueueWaitIdle(VkQueue queue) const VULKAN_HPP_NOEXCEPT {
-    return ::vkQueueWaitIdle(queue);
-  }
-
-  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 vkReleaseDisplayEXT(VkPhysicalDevice physicalDevice,
-                               VkDisplayKHR display) const VULKAN_HPP_NOEXCEPT {
-    return ::vkReleaseDisplayEXT(physicalDevice, display);
-  }
-
-#if defined(VK_USE_PLATFORM_WIN32_KHR)
-  VkResult vkReleaseFullScreenExclusiveModeEXT(
-      VkDevice device, VkSwapchainKHR swapchain) const VULKAN_HPP_NOEXCEPT {
-    return ::vkReleaseFullScreenExclusiveModeEXT(device, swapchain);
-  }
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-  VkResult vkReleasePerformanceConfigurationINTEL(
-      VkDevice device,
-      VkPerformanceConfigurationINTEL configuration) const VULKAN_HPP_NOEXCEPT {
-    return ::vkReleasePerformanceConfigurationINTEL(device, configuration);
-  }
-
-  void vkReleaseProfilingLockKHR(VkDevice device) const VULKAN_HPP_NOEXCEPT {
-    return ::vkReleaseProfilingLockKHR(device);
-  }
-
-  VkResult vkResetCommandBuffer(VkCommandBuffer commandBuffer,
-                                VkCommandBufferResetFlags flags) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkResetCommandBuffer(commandBuffer, flags);
-  }
-
-  VkResult
-  vkResetCommandPool(VkDevice device, VkCommandPool commandPool,
-                     VkCommandPoolResetFlags flags) const VULKAN_HPP_NOEXCEPT {
-    return ::vkResetCommandPool(device, commandPool, flags);
-  }
-
-  VkResult vkResetDescriptorPool(
-      VkDevice device, VkDescriptorPool descriptorPool,
-      VkDescriptorPoolResetFlags flags) const VULKAN_HPP_NOEXCEPT {
-    return ::vkResetDescriptorPool(device, descriptorPool, flags);
-  }
-
-  VkResult vkResetEvent(VkDevice device,
-                        VkEvent event) const VULKAN_HPP_NOEXCEPT {
-    return ::vkResetEvent(device, event);
-  }
-
-  VkResult vkResetFences(VkDevice device, uint32_t fenceCount,
-                         const VkFence *pFences) const VULKAN_HPP_NOEXCEPT {
-    return ::vkResetFences(device, fenceCount, pFences);
-  }
-
-  void vkResetQueryPool(VkDevice device, VkQueryPool queryPool,
-                        uint32_t firstQuery,
-                        uint32_t queryCount) const VULKAN_HPP_NOEXCEPT {
-    return ::vkResetQueryPool(device, queryPool, firstQuery, queryCount);
-  }
-
-  void vkResetQueryPoolEXT(VkDevice device, VkQueryPool queryPool,
-                           uint32_t firstQuery,
-                           uint32_t queryCount) const VULKAN_HPP_NOEXCEPT {
-    return ::vkResetQueryPoolEXT(device, queryPool, firstQuery, queryCount);
-  }
-
 #if defined(VK_USE_PLATFORM_FUCHSIA)
-  VkResult vkSetBufferCollectionBufferConstraintsFUCHSIA(
-      VkDevice device, VkBufferCollectionFUCHSIA collection,
-      const VkBufferConstraintsInfoFUCHSIA *pBufferConstraintsInfo) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkSetBufferCollectionBufferConstraintsFUCHSIA(
-        device, collection, pBufferConstraintsInfo);
+
+  //=== 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 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 ===
+
+  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);
+  }
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+
+  //=== VK_FUCHSIA_buffer_collection_x ===
+
+  VkResult vkCreateBufferCollectionFUCHSIAX(
+      VkDevice device, const VkBufferCollectionCreateInfoFUCHSIAX *pImportInfo,
+      const VkAllocationCallbacks *pAllocator,
+      VkBufferCollectionFUCHSIAX *pCollection) const VULKAN_HPP_NOEXCEPT {
+    return ::vkCreateBufferCollectionFUCHSIAX(device, pImportInfo, pAllocator,
+                                              pCollection);
+  }
+
+  VkResult vkSetBufferCollectionConstraintsFUCHSIAX(
+      VkDevice device, VkBufferCollectionFUCHSIAX collection,
+      const VkImageCreateInfo *pImageInfo) const VULKAN_HPP_NOEXCEPT {
+    return ::vkSetBufferCollectionConstraintsFUCHSIAX(device, collection,
+                                                      pImageInfo);
+  }
+
+  VkResult vkSetBufferCollectionImageConstraintsFUCHSIAX(
+      VkDevice device, VkBufferCollectionFUCHSIAX collection,
+      const VkImageConstraintsInfoFUCHSIAX *pImageConstraintsInfo) const
+      VULKAN_HPP_NOEXCEPT {
+    return ::vkSetBufferCollectionImageConstraintsFUCHSIAX(
+        device, collection, pImageConstraintsInfo);
+  }
+
+  VkResult vkSetBufferCollectionBufferConstraintsFUCHSIAX(
+      VkDevice device, VkBufferCollectionFUCHSIAX collection,
+      const VkBufferConstraintsInfoFUCHSIAX *pBufferConstraintsInfo) const
+      VULKAN_HPP_NOEXCEPT {
+    return ::vkSetBufferCollectionBufferConstraintsFUCHSIAX(
+        device, collection, pBufferConstraintsInfo);
+  }
+
+  void vkDestroyBufferCollectionFUCHSIAX(
+      VkDevice device, VkBufferCollectionFUCHSIAX collection,
+      const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT {
+    return ::vkDestroyBufferCollectionFUCHSIAX(device, collection, pAllocator);
+  }
+
+  VkResult vkGetBufferCollectionPropertiesFUCHSIAX(
+      VkDevice device, VkBufferCollectionFUCHSIAX collection,
+      VkBufferCollectionPropertiesFUCHSIAX *pProperties) const
+      VULKAN_HPP_NOEXCEPT {
+    return ::vkGetBufferCollectionPropertiesFUCHSIAX(device, collection,
+                                                     pProperties);
+  }
+
+  VkResult vkGetBufferCollectionProperties2FUCHSIAX(
+      VkDevice device, VkBufferCollectionFUCHSIAX collection,
+      VkBufferCollectionProperties2FUCHSIAX *pProperties) const
+      VULKAN_HPP_NOEXCEPT {
+    return ::vkGetBufferCollectionProperties2FUCHSIAX(device, collection,
+                                                      pProperties);
+  }
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+
+#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*/
+
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+
+  //=== VK_FUCHSIA_buffer_collection ===
+
+  VkResult vkCreateBufferCollectionFUCHSIA(
+      VkDevice device, const VkBufferCollectionCreateInfoFUCHSIA *pImportInfo,
+      const VkAllocationCallbacks *pAllocator,
+      VkBufferCollectionFUCHSIA *pCollection) const VULKAN_HPP_NOEXCEPT {
+    return ::vkCreateBufferCollectionFUCHSIA(device, pImportInfo, pAllocator,
+                                             pCollection);
+  }
+
   VkResult vkSetBufferCollectionConstraintsFUCHSIA(
       VkDevice device, VkBufferCollectionFUCHSIA collection,
       const VkImageCreateInfo *pImageInfo) const VULKAN_HPP_NOEXCEPT {
     return ::vkSetBufferCollectionConstraintsFUCHSIA(device, collection,
                                                      pImageInfo);
   }
-#endif /*VK_USE_PLATFORM_FUCHSIA*/
 
-#if defined(VK_USE_PLATFORM_FUCHSIA)
   VkResult vkSetBufferCollectionImageConstraintsFUCHSIA(
       VkDevice device, VkBufferCollectionFUCHSIA collection,
       const VkImageConstraintsInfoFUCHSIA *pImageConstraintsInfo) const
@@ -4609,82 +4959,42 @@
     return ::vkSetBufferCollectionImageConstraintsFUCHSIA(
         device, collection, pImageConstraintsInfo);
   }
+
+  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);
+  }
+
+  VkResult vkGetBufferCollectionProperties2FUCHSIA(
+      VkDevice device, VkBufferCollectionFUCHSIA collection,
+      VkBufferCollectionProperties2FUCHSIA *pProperties) const
+      VULKAN_HPP_NOEXCEPT {
+    return ::vkGetBufferCollectionProperties2FUCHSIA(device, collection,
+                                                     pProperties);
+  }
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 
-  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);
-  }
-
-  VkResult vkSetEvent(VkDevice device,
-                      VkEvent event) const VULKAN_HPP_NOEXCEPT {
-    return ::vkSetEvent(device, event);
-  }
-
-  void vkSetHdrMetadataEXT(VkDevice device, uint32_t swapchainCount,
-                           const VkSwapchainKHR *pSwapchains,
-                           const VkHdrMetadataEXT *pMetadata) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkSetHdrMetadataEXT(device, swapchainCount, pSwapchains,
-                                 pMetadata);
-  }
-
-  void
-  vkSetLocalDimmingAMD(VkDevice device, VkSwapchainKHR swapChain,
-                       VkBool32 localDimmingEnable) const VULKAN_HPP_NOEXCEPT {
-    return ::vkSetLocalDimmingAMD(device, swapChain, localDimmingEnable);
-  }
-
-  VkResult vkSetPrivateDataEXT(VkDevice device, VkObjectType objectType,
-                               uint64_t objectHandle,
-                               VkPrivateDataSlotEXT privateDataSlot,
-                               uint64_t data) const VULKAN_HPP_NOEXCEPT {
-    return ::vkSetPrivateDataEXT(device, objectType, objectHandle,
-                                 privateDataSlot, data);
-  }
-
-  VkResult vkSignalSemaphore(VkDevice device,
-                             const VkSemaphoreSignalInfo *pSignalInfo) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkSignalSemaphore(device, pSignalInfo);
-  }
-
-  VkResult vkSignalSemaphoreKHR(VkDevice device,
-                                const VkSemaphoreSignalInfo *pSignalInfo) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkSignalSemaphoreKHR(device, pSignalInfo);
-  }
-
-  void vkSubmitDebugUtilsMessageEXT(
-      VkInstance instance,
-      VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
-      VkDebugUtilsMessageTypeFlagsEXT messageTypes,
-      const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData) const
-      VULKAN_HPP_NOEXCEPT {
-    return ::vkSubmitDebugUtilsMessageEXT(instance, messageSeverity,
-                                          messageTypes, pCallbackData);
-  }
-
-  void
-  vkTrimCommandPool(VkDevice device, VkCommandPool commandPool,
-                    VkCommandPoolTrimFlags flags) const VULKAN_HPP_NOEXCEPT {
-    return ::vkTrimCommandPool(device, commandPool, flags);
-  }
-
-  void
-  vkTrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool,
-                       VkCommandPoolTrimFlags flags) const VULKAN_HPP_NOEXCEPT {
-    return ::vkTrimCommandPoolKHR(device, commandPool, flags);
-  }
-
 #if defined(VK_USE_PLATFORM_FUCHSIA)
+
+  //=== VK_FUCHSIA_compact_image ===
+
   VkResult vkTrimCompactImageDeviceMemoryFUCHSIA(
       VkDevice device, VkImage image, VkDeviceMemory memory,
       VkDeviceSize memoryOffset) const VULKAN_HPP_NOEXCEPT {
@@ -4692,70 +5002,6 @@
                                                    memoryOffset);
   }
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
-
-  void
-  vkUninitializePerformanceApiINTEL(VkDevice device) const VULKAN_HPP_NOEXCEPT {
-    return ::vkUninitializePerformanceApiINTEL(device);
-  }
-
-  void vkUnmapMemory(VkDevice device,
-                     VkDeviceMemory memory) const VULKAN_HPP_NOEXCEPT {
-    return ::vkUnmapMemory(device, memory);
-  }
-
-  void vkUpdateDescriptorSetWithTemplate(
-      VkDevice device, VkDescriptorSet descriptorSet,
-      VkDescriptorUpdateTemplate descriptorUpdateTemplate,
-      const void *pData) const VULKAN_HPP_NOEXCEPT {
-    return ::vkUpdateDescriptorSetWithTemplate(device, descriptorSet,
-                                               descriptorUpdateTemplate, pData);
-  }
-
-  void vkUpdateDescriptorSetWithTemplateKHR(
-      VkDevice device, VkDescriptorSet descriptorSet,
-      VkDescriptorUpdateTemplate descriptorUpdateTemplate,
-      const void *pData) const VULKAN_HPP_NOEXCEPT {
-    return ::vkUpdateDescriptorSetWithTemplateKHR(
-        device, descriptorSet, descriptorUpdateTemplate, pData);
-  }
-
-  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 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 vkWaitSemaphores(VkDevice device,
-                            const VkSemaphoreWaitInfo *pWaitInfo,
-                            uint64_t timeout) const VULKAN_HPP_NOEXCEPT {
-    return ::vkWaitSemaphores(device, pWaitInfo, timeout);
-  }
-
-  VkResult vkWaitSemaphoresKHR(VkDevice device,
-                               const VkSemaphoreWaitInfo *pWaitInfo,
-                               uint64_t timeout) const VULKAN_HPP_NOEXCEPT {
-    return ::vkWaitSemaphoresKHR(device, pWaitInfo, timeout);
-  }
-
-  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);
-  }
 };
 #endif
 
@@ -4979,5570 +5225,65 @@
   return stream.str();
 }
 
-enum class AccelerationStructureBuildTypeKHR {
-  eHost = VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_KHR,
-  eDevice = VK_ACCELERATION_STRUCTURE_BUILD_TYPE_DEVICE_KHR,
-  eHostOrDevice = VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_OR_DEVICE_KHR
-};
+//=============
+//=== ENUMs ===
+//=============
 
-VULKAN_HPP_INLINE std::string
-to_string(AccelerationStructureBuildTypeKHR value) {
-  switch (value) {
-  case AccelerationStructureBuildTypeKHR::eHost:
-    return "Host";
-  case AccelerationStructureBuildTypeKHR::eDevice:
-    return "Device";
-  case AccelerationStructureBuildTypeKHR::eHostOrDevice:
-    return "HostOrDevice";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class AccelerationStructureCompatibilityKHR {
-  eCompatible = VK_ACCELERATION_STRUCTURE_COMPATIBILITY_COMPATIBLE_KHR,
-  eIncompatible = VK_ACCELERATION_STRUCTURE_COMPATIBILITY_INCOMPATIBLE_KHR
-};
-
-VULKAN_HPP_INLINE std::string
-to_string(AccelerationStructureCompatibilityKHR value) {
-  switch (value) {
-  case AccelerationStructureCompatibilityKHR::eCompatible:
-    return "Compatible";
-  case AccelerationStructureCompatibilityKHR::eIncompatible:
-    return "Incompatible";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class
-    AccelerationStructureCreateFlagBitsKHR : VkAccelerationStructureCreateFlagsKHR {
-      eDeviceAddressCaptureReplay =
-          VK_ACCELERATION_STRUCTURE_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR
-    };
-
-VULKAN_HPP_INLINE std::string
-to_string(AccelerationStructureCreateFlagBitsKHR value) {
-  switch (value) {
-  case AccelerationStructureCreateFlagBitsKHR::eDeviceAddressCaptureReplay:
-    return "DeviceAddressCaptureReplay";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class AccelerationStructureMemoryRequirementsTypeNV {
-  eObject = VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV,
-  eBuildScratch =
-      VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_NV,
-  eUpdateScratch =
-      VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV
-};
-
-VULKAN_HPP_INLINE std::string
-to_string(AccelerationStructureMemoryRequirementsTypeNV value) {
-  switch (value) {
-  case AccelerationStructureMemoryRequirementsTypeNV::eObject:
-    return "Object";
-  case AccelerationStructureMemoryRequirementsTypeNV::eBuildScratch:
-    return "BuildScratch";
-  case AccelerationStructureMemoryRequirementsTypeNV::eUpdateScratch:
-    return "UpdateScratch";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class AccelerationStructureTypeKHR {
-  eTopLevel = VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR,
-  eBottomLevel = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR,
-  eGeneric = VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR
-};
-using AccelerationStructureTypeNV = AccelerationStructureTypeKHR;
-
-VULKAN_HPP_INLINE std::string to_string(AccelerationStructureTypeKHR value) {
-  switch (value) {
-  case AccelerationStructureTypeKHR::eTopLevel:
-    return "TopLevel";
-  case AccelerationStructureTypeKHR::eBottomLevel:
-    return "BottomLevel";
-  case AccelerationStructureTypeKHR::eGeneric:
-    return "Generic";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class AccessFlagBits : VkAccessFlags {
-  eIndirectCommandRead = VK_ACCESS_INDIRECT_COMMAND_READ_BIT,
-  eIndexRead = VK_ACCESS_INDEX_READ_BIT,
-  eVertexAttributeRead = VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT,
-  eUniformRead = VK_ACCESS_UNIFORM_READ_BIT,
-  eInputAttachmentRead = VK_ACCESS_INPUT_ATTACHMENT_READ_BIT,
-  eShaderRead = VK_ACCESS_SHADER_READ_BIT,
-  eShaderWrite = VK_ACCESS_SHADER_WRITE_BIT,
-  eColorAttachmentRead = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT,
-  eColorAttachmentWrite = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
-  eDepthStencilAttachmentRead = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT,
-  eDepthStencilAttachmentWrite = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
-  eTransferRead = VK_ACCESS_TRANSFER_READ_BIT,
-  eTransferWrite = VK_ACCESS_TRANSFER_WRITE_BIT,
-  eHostRead = VK_ACCESS_HOST_READ_BIT,
-  eHostWrite = VK_ACCESS_HOST_WRITE_BIT,
-  eMemoryRead = VK_ACCESS_MEMORY_READ_BIT,
-  eMemoryWrite = VK_ACCESS_MEMORY_WRITE_BIT,
-  eTransformFeedbackWriteEXT = VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT,
-  eTransformFeedbackCounterReadEXT =
-      VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT,
-  eTransformFeedbackCounterWriteEXT =
-      VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT,
-  eConditionalRenderingReadEXT = VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT,
-  eColorAttachmentReadNoncoherentEXT =
-      VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT,
-  eAccelerationStructureReadKHR = VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR,
-  eAccelerationStructureWriteKHR =
-      VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR,
-  eShadingRateImageReadNV = VK_ACCESS_SHADING_RATE_IMAGE_READ_BIT_NV,
-  eFragmentDensityMapReadEXT = VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT,
-  eCommandPreprocessReadNV = VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_NV,
-  eCommandPreprocessWriteNV = VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_NV,
-  eNoneKHR = VK_ACCESS_NONE_KHR,
-  eAccelerationStructureReadNV = VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NV,
-  eAccelerationStructureWriteNV = VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NV,
-  eFragmentShadingRateAttachmentReadKHR =
-      VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR
-};
-
-VULKAN_HPP_INLINE std::string to_string(AccessFlagBits value) {
-  switch (value) {
-  case AccessFlagBits::eIndirectCommandRead:
-    return "IndirectCommandRead";
-  case AccessFlagBits::eIndexRead:
-    return "IndexRead";
-  case AccessFlagBits::eVertexAttributeRead:
-    return "VertexAttributeRead";
-  case AccessFlagBits::eUniformRead:
-    return "UniformRead";
-  case AccessFlagBits::eInputAttachmentRead:
-    return "InputAttachmentRead";
-  case AccessFlagBits::eShaderRead:
-    return "ShaderRead";
-  case AccessFlagBits::eShaderWrite:
-    return "ShaderWrite";
-  case AccessFlagBits::eColorAttachmentRead:
-    return "ColorAttachmentRead";
-  case AccessFlagBits::eColorAttachmentWrite:
-    return "ColorAttachmentWrite";
-  case AccessFlagBits::eDepthStencilAttachmentRead:
-    return "DepthStencilAttachmentRead";
-  case AccessFlagBits::eDepthStencilAttachmentWrite:
-    return "DepthStencilAttachmentWrite";
-  case AccessFlagBits::eTransferRead:
-    return "TransferRead";
-  case AccessFlagBits::eTransferWrite:
-    return "TransferWrite";
-  case AccessFlagBits::eHostRead:
-    return "HostRead";
-  case AccessFlagBits::eHostWrite:
-    return "HostWrite";
-  case AccessFlagBits::eMemoryRead:
-    return "MemoryRead";
-  case AccessFlagBits::eMemoryWrite:
-    return "MemoryWrite";
-  case AccessFlagBits::eTransformFeedbackWriteEXT:
-    return "TransformFeedbackWriteEXT";
-  case AccessFlagBits::eTransformFeedbackCounterReadEXT:
-    return "TransformFeedbackCounterReadEXT";
-  case AccessFlagBits::eTransformFeedbackCounterWriteEXT:
-    return "TransformFeedbackCounterWriteEXT";
-  case AccessFlagBits::eConditionalRenderingReadEXT:
-    return "ConditionalRenderingReadEXT";
-  case AccessFlagBits::eColorAttachmentReadNoncoherentEXT:
-    return "ColorAttachmentReadNoncoherentEXT";
-  case AccessFlagBits::eAccelerationStructureReadKHR:
-    return "AccelerationStructureReadKHR";
-  case AccessFlagBits::eAccelerationStructureWriteKHR:
-    return "AccelerationStructureWriteKHR";
-  case AccessFlagBits::eShadingRateImageReadNV:
-    return "ShadingRateImageReadNV";
-  case AccessFlagBits::eFragmentDensityMapReadEXT:
-    return "FragmentDensityMapReadEXT";
-  case AccessFlagBits::eCommandPreprocessReadNV:
-    return "CommandPreprocessReadNV";
-  case AccessFlagBits::eCommandPreprocessWriteNV:
-    return "CommandPreprocessWriteNV";
-  case AccessFlagBits::eNoneKHR:
-    return "NoneKHR";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class AccessFlagBits2KHR : VkAccessFlags2KHR {
-  eNone = VK_ACCESS_2_NONE_KHR,
-  eIndirectCommandRead = VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT_KHR,
-  eIndexRead = VK_ACCESS_2_INDEX_READ_BIT_KHR,
-  eVertexAttributeRead = VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT_KHR,
-  eUniformRead = VK_ACCESS_2_UNIFORM_READ_BIT_KHR,
-  eInputAttachmentRead = VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT_KHR,
-  eShaderRead = VK_ACCESS_2_SHADER_READ_BIT_KHR,
-  eShaderWrite = VK_ACCESS_2_SHADER_WRITE_BIT_KHR,
-  eColorAttachmentRead = VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT_KHR,
-  eColorAttachmentWrite = VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT_KHR,
-  eDepthStencilAttachmentRead =
-      VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT_KHR,
-  eDepthStencilAttachmentWrite =
-      VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT_KHR,
-  eTransferRead = VK_ACCESS_2_TRANSFER_READ_BIT_KHR,
-  eTransferWrite = VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR,
-  eHostRead = VK_ACCESS_2_HOST_READ_BIT_KHR,
-  eHostWrite = VK_ACCESS_2_HOST_WRITE_BIT_KHR,
-  eMemoryRead = VK_ACCESS_2_MEMORY_READ_BIT_KHR,
-  eMemoryWrite = VK_ACCESS_2_MEMORY_WRITE_BIT_KHR,
-  eShaderSampledRead = VK_ACCESS_2_SHADER_SAMPLED_READ_BIT_KHR,
-  eShaderStorageRead = VK_ACCESS_2_SHADER_STORAGE_READ_BIT_KHR,
-  eShaderStorageWrite = VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT_KHR,
-  eTransformFeedbackWriteExt = VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT,
-  eTransformFeedbackCounterReadExt =
-      VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT,
-  eTransformFeedbackCounterWriteExt =
-      VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT,
-  eConditionalRenderingReadExt = VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT,
-  eCommandPreprocessReadNv = VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV,
-  eCommandPreprocessWriteNv = VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV,
-  eFragmentShadingRateAttachmentRead =
-      VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR,
-  eAccelerationStructureRead = VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR,
-  eAccelerationStructureWrite =
-      VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR,
-  eFragmentDensityMapReadExt = VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT,
-  eColorAttachmentReadNoncoherentExt =
-      VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT,
-  eAccelerationStructureReadNv = VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_NV,
-  eAccelerationStructureWriteNv =
-      VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_NV,
-  eShadingRateImageReadNv = VK_ACCESS_2_SHADING_RATE_IMAGE_READ_BIT_NV
-};
-
-VULKAN_HPP_INLINE std::string to_string(AccessFlagBits2KHR value) {
-  switch (value) {
-  case AccessFlagBits2KHR::eNone:
-    return "None";
-  case AccessFlagBits2KHR::eIndirectCommandRead:
-    return "IndirectCommandRead";
-  case AccessFlagBits2KHR::eIndexRead:
-    return "IndexRead";
-  case AccessFlagBits2KHR::eVertexAttributeRead:
-    return "VertexAttributeRead";
-  case AccessFlagBits2KHR::eUniformRead:
-    return "UniformRead";
-  case AccessFlagBits2KHR::eInputAttachmentRead:
-    return "InputAttachmentRead";
-  case AccessFlagBits2KHR::eShaderRead:
-    return "ShaderRead";
-  case AccessFlagBits2KHR::eShaderWrite:
-    return "ShaderWrite";
-  case AccessFlagBits2KHR::eColorAttachmentRead:
-    return "ColorAttachmentRead";
-  case AccessFlagBits2KHR::eColorAttachmentWrite:
-    return "ColorAttachmentWrite";
-  case AccessFlagBits2KHR::eDepthStencilAttachmentRead:
-    return "DepthStencilAttachmentRead";
-  case AccessFlagBits2KHR::eDepthStencilAttachmentWrite:
-    return "DepthStencilAttachmentWrite";
-  case AccessFlagBits2KHR::eTransferRead:
-    return "TransferRead";
-  case AccessFlagBits2KHR::eTransferWrite:
-    return "TransferWrite";
-  case AccessFlagBits2KHR::eHostRead:
-    return "HostRead";
-  case AccessFlagBits2KHR::eHostWrite:
-    return "HostWrite";
-  case AccessFlagBits2KHR::eMemoryRead:
-    return "MemoryRead";
-  case AccessFlagBits2KHR::eMemoryWrite:
-    return "MemoryWrite";
-  case AccessFlagBits2KHR::eShaderSampledRead:
-    return "ShaderSampledRead";
-  case AccessFlagBits2KHR::eShaderStorageRead:
-    return "ShaderStorageRead";
-  case AccessFlagBits2KHR::eShaderStorageWrite:
-    return "ShaderStorageWrite";
-  case AccessFlagBits2KHR::eTransformFeedbackWriteExt:
-    return "TransformFeedbackWriteExt";
-  case AccessFlagBits2KHR::eTransformFeedbackCounterReadExt:
-    return "TransformFeedbackCounterReadExt";
-  case AccessFlagBits2KHR::eTransformFeedbackCounterWriteExt:
-    return "TransformFeedbackCounterWriteExt";
-  case AccessFlagBits2KHR::eConditionalRenderingReadExt:
-    return "ConditionalRenderingReadExt";
-  case AccessFlagBits2KHR::eCommandPreprocessReadNv:
-    return "CommandPreprocessReadNv";
-  case AccessFlagBits2KHR::eCommandPreprocessWriteNv:
-    return "CommandPreprocessWriteNv";
-  case AccessFlagBits2KHR::eFragmentShadingRateAttachmentRead:
-    return "FragmentShadingRateAttachmentRead";
-  case AccessFlagBits2KHR::eAccelerationStructureRead:
-    return "AccelerationStructureRead";
-  case AccessFlagBits2KHR::eAccelerationStructureWrite:
-    return "AccelerationStructureWrite";
-  case AccessFlagBits2KHR::eFragmentDensityMapReadExt:
-    return "FragmentDensityMapReadExt";
-  case AccessFlagBits2KHR::eColorAttachmentReadNoncoherentExt:
-    return "ColorAttachmentReadNoncoherentExt";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class AcquireProfilingLockFlagBitsKHR : VkAcquireProfilingLockFlagsKHR {};
-
-VULKAN_HPP_INLINE std::string to_string(AcquireProfilingLockFlagBitsKHR) {
-  return "(void)";
-}
-
-enum class AttachmentDescriptionFlagBits : VkAttachmentDescriptionFlags {
-  eMayAlias = VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT
-};
-
-VULKAN_HPP_INLINE std::string to_string(AttachmentDescriptionFlagBits value) {
-  switch (value) {
-  case AttachmentDescriptionFlagBits::eMayAlias:
-    return "MayAlias";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class AttachmentLoadOp {
-  eLoad = VK_ATTACHMENT_LOAD_OP_LOAD,
-  eClear = VK_ATTACHMENT_LOAD_OP_CLEAR,
-  eDontCare = VK_ATTACHMENT_LOAD_OP_DONT_CARE
-};
-
-VULKAN_HPP_INLINE std::string to_string(AttachmentLoadOp value) {
-  switch (value) {
-  case AttachmentLoadOp::eLoad:
-    return "Load";
-  case AttachmentLoadOp::eClear:
-    return "Clear";
-  case AttachmentLoadOp::eDontCare:
-    return "DontCare";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class AttachmentStoreOp {
-  eStore = VK_ATTACHMENT_STORE_OP_STORE,
-  eDontCare = VK_ATTACHMENT_STORE_OP_DONT_CARE,
-  eNoneQCOM = VK_ATTACHMENT_STORE_OP_NONE_QCOM
-};
-
-VULKAN_HPP_INLINE std::string to_string(AttachmentStoreOp value) {
-  switch (value) {
-  case AttachmentStoreOp::eStore:
-    return "Store";
-  case AttachmentStoreOp::eDontCare:
-    return "DontCare";
-  case AttachmentStoreOp::eNoneQCOM:
-    return "NoneQCOM";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class BlendFactor {
-  eZero = VK_BLEND_FACTOR_ZERO,
-  eOne = VK_BLEND_FACTOR_ONE,
-  eSrcColor = VK_BLEND_FACTOR_SRC_COLOR,
-  eOneMinusSrcColor = VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR,
-  eDstColor = VK_BLEND_FACTOR_DST_COLOR,
-  eOneMinusDstColor = VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR,
-  eSrcAlpha = VK_BLEND_FACTOR_SRC_ALPHA,
-  eOneMinusSrcAlpha = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,
-  eDstAlpha = VK_BLEND_FACTOR_DST_ALPHA,
-  eOneMinusDstAlpha = VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA,
-  eConstantColor = VK_BLEND_FACTOR_CONSTANT_COLOR,
-  eOneMinusConstantColor = VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR,
-  eConstantAlpha = VK_BLEND_FACTOR_CONSTANT_ALPHA,
-  eOneMinusConstantAlpha = VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA,
-  eSrcAlphaSaturate = VK_BLEND_FACTOR_SRC_ALPHA_SATURATE,
-  eSrc1Color = VK_BLEND_FACTOR_SRC1_COLOR,
-  eOneMinusSrc1Color = VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR,
-  eSrc1Alpha = VK_BLEND_FACTOR_SRC1_ALPHA,
-  eOneMinusSrc1Alpha = VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA
-};
-
-VULKAN_HPP_INLINE std::string to_string(BlendFactor value) {
-  switch (value) {
-  case BlendFactor::eZero:
-    return "Zero";
-  case BlendFactor::eOne:
-    return "One";
-  case BlendFactor::eSrcColor:
-    return "SrcColor";
-  case BlendFactor::eOneMinusSrcColor:
-    return "OneMinusSrcColor";
-  case BlendFactor::eDstColor:
-    return "DstColor";
-  case BlendFactor::eOneMinusDstColor:
-    return "OneMinusDstColor";
-  case BlendFactor::eSrcAlpha:
-    return "SrcAlpha";
-  case BlendFactor::eOneMinusSrcAlpha:
-    return "OneMinusSrcAlpha";
-  case BlendFactor::eDstAlpha:
-    return "DstAlpha";
-  case BlendFactor::eOneMinusDstAlpha:
-    return "OneMinusDstAlpha";
-  case BlendFactor::eConstantColor:
-    return "ConstantColor";
-  case BlendFactor::eOneMinusConstantColor:
-    return "OneMinusConstantColor";
-  case BlendFactor::eConstantAlpha:
-    return "ConstantAlpha";
-  case BlendFactor::eOneMinusConstantAlpha:
-    return "OneMinusConstantAlpha";
-  case BlendFactor::eSrcAlphaSaturate:
-    return "SrcAlphaSaturate";
-  case BlendFactor::eSrc1Color:
-    return "Src1Color";
-  case BlendFactor::eOneMinusSrc1Color:
-    return "OneMinusSrc1Color";
-  case BlendFactor::eSrc1Alpha:
-    return "Src1Alpha";
-  case BlendFactor::eOneMinusSrc1Alpha:
-    return "OneMinusSrc1Alpha";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class BlendOp {
-  eAdd = VK_BLEND_OP_ADD,
-  eSubtract = VK_BLEND_OP_SUBTRACT,
-  eReverseSubtract = VK_BLEND_OP_REVERSE_SUBTRACT,
-  eMin = VK_BLEND_OP_MIN,
-  eMax = VK_BLEND_OP_MAX,
-  eZeroEXT = VK_BLEND_OP_ZERO_EXT,
-  eSrcEXT = VK_BLEND_OP_SRC_EXT,
-  eDstEXT = VK_BLEND_OP_DST_EXT,
-  eSrcOverEXT = VK_BLEND_OP_SRC_OVER_EXT,
-  eDstOverEXT = VK_BLEND_OP_DST_OVER_EXT,
-  eSrcInEXT = VK_BLEND_OP_SRC_IN_EXT,
-  eDstInEXT = VK_BLEND_OP_DST_IN_EXT,
-  eSrcOutEXT = VK_BLEND_OP_SRC_OUT_EXT,
-  eDstOutEXT = VK_BLEND_OP_DST_OUT_EXT,
-  eSrcAtopEXT = VK_BLEND_OP_SRC_ATOP_EXT,
-  eDstAtopEXT = VK_BLEND_OP_DST_ATOP_EXT,
-  eXorEXT = VK_BLEND_OP_XOR_EXT,
-  eMultiplyEXT = VK_BLEND_OP_MULTIPLY_EXT,
-  eScreenEXT = VK_BLEND_OP_SCREEN_EXT,
-  eOverlayEXT = VK_BLEND_OP_OVERLAY_EXT,
-  eDarkenEXT = VK_BLEND_OP_DARKEN_EXT,
-  eLightenEXT = VK_BLEND_OP_LIGHTEN_EXT,
-  eColordodgeEXT = VK_BLEND_OP_COLORDODGE_EXT,
-  eColorburnEXT = VK_BLEND_OP_COLORBURN_EXT,
-  eHardlightEXT = VK_BLEND_OP_HARDLIGHT_EXT,
-  eSoftlightEXT = VK_BLEND_OP_SOFTLIGHT_EXT,
-  eDifferenceEXT = VK_BLEND_OP_DIFFERENCE_EXT,
-  eExclusionEXT = VK_BLEND_OP_EXCLUSION_EXT,
-  eInvertEXT = VK_BLEND_OP_INVERT_EXT,
-  eInvertRgbEXT = VK_BLEND_OP_INVERT_RGB_EXT,
-  eLineardodgeEXT = VK_BLEND_OP_LINEARDODGE_EXT,
-  eLinearburnEXT = VK_BLEND_OP_LINEARBURN_EXT,
-  eVividlightEXT = VK_BLEND_OP_VIVIDLIGHT_EXT,
-  eLinearlightEXT = VK_BLEND_OP_LINEARLIGHT_EXT,
-  ePinlightEXT = VK_BLEND_OP_PINLIGHT_EXT,
-  eHardmixEXT = VK_BLEND_OP_HARDMIX_EXT,
-  eHslHueEXT = VK_BLEND_OP_HSL_HUE_EXT,
-  eHslSaturationEXT = VK_BLEND_OP_HSL_SATURATION_EXT,
-  eHslColorEXT = VK_BLEND_OP_HSL_COLOR_EXT,
-  eHslLuminosityEXT = VK_BLEND_OP_HSL_LUMINOSITY_EXT,
-  ePlusEXT = VK_BLEND_OP_PLUS_EXT,
-  ePlusClampedEXT = VK_BLEND_OP_PLUS_CLAMPED_EXT,
-  ePlusClampedAlphaEXT = VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT,
-  ePlusDarkerEXT = VK_BLEND_OP_PLUS_DARKER_EXT,
-  eMinusEXT = VK_BLEND_OP_MINUS_EXT,
-  eMinusClampedEXT = VK_BLEND_OP_MINUS_CLAMPED_EXT,
-  eContrastEXT = VK_BLEND_OP_CONTRAST_EXT,
-  eInvertOvgEXT = VK_BLEND_OP_INVERT_OVG_EXT,
-  eRedEXT = VK_BLEND_OP_RED_EXT,
-  eGreenEXT = VK_BLEND_OP_GREEN_EXT,
-  eBlueEXT = VK_BLEND_OP_BLUE_EXT
-};
-
-VULKAN_HPP_INLINE std::string to_string(BlendOp value) {
-  switch (value) {
-  case BlendOp::eAdd:
-    return "Add";
-  case BlendOp::eSubtract:
-    return "Subtract";
-  case BlendOp::eReverseSubtract:
-    return "ReverseSubtract";
-  case BlendOp::eMin:
-    return "Min";
-  case BlendOp::eMax:
-    return "Max";
-  case BlendOp::eZeroEXT:
-    return "ZeroEXT";
-  case BlendOp::eSrcEXT:
-    return "SrcEXT";
-  case BlendOp::eDstEXT:
-    return "DstEXT";
-  case BlendOp::eSrcOverEXT:
-    return "SrcOverEXT";
-  case BlendOp::eDstOverEXT:
-    return "DstOverEXT";
-  case BlendOp::eSrcInEXT:
-    return "SrcInEXT";
-  case BlendOp::eDstInEXT:
-    return "DstInEXT";
-  case BlendOp::eSrcOutEXT:
-    return "SrcOutEXT";
-  case BlendOp::eDstOutEXT:
-    return "DstOutEXT";
-  case BlendOp::eSrcAtopEXT:
-    return "SrcAtopEXT";
-  case BlendOp::eDstAtopEXT:
-    return "DstAtopEXT";
-  case BlendOp::eXorEXT:
-    return "XorEXT";
-  case BlendOp::eMultiplyEXT:
-    return "MultiplyEXT";
-  case BlendOp::eScreenEXT:
-    return "ScreenEXT";
-  case BlendOp::eOverlayEXT:
-    return "OverlayEXT";
-  case BlendOp::eDarkenEXT:
-    return "DarkenEXT";
-  case BlendOp::eLightenEXT:
-    return "LightenEXT";
-  case BlendOp::eColordodgeEXT:
-    return "ColordodgeEXT";
-  case BlendOp::eColorburnEXT:
-    return "ColorburnEXT";
-  case BlendOp::eHardlightEXT:
-    return "HardlightEXT";
-  case BlendOp::eSoftlightEXT:
-    return "SoftlightEXT";
-  case BlendOp::eDifferenceEXT:
-    return "DifferenceEXT";
-  case BlendOp::eExclusionEXT:
-    return "ExclusionEXT";
-  case BlendOp::eInvertEXT:
-    return "InvertEXT";
-  case BlendOp::eInvertRgbEXT:
-    return "InvertRgbEXT";
-  case BlendOp::eLineardodgeEXT:
-    return "LineardodgeEXT";
-  case BlendOp::eLinearburnEXT:
-    return "LinearburnEXT";
-  case BlendOp::eVividlightEXT:
-    return "VividlightEXT";
-  case BlendOp::eLinearlightEXT:
-    return "LinearlightEXT";
-  case BlendOp::ePinlightEXT:
-    return "PinlightEXT";
-  case BlendOp::eHardmixEXT:
-    return "HardmixEXT";
-  case BlendOp::eHslHueEXT:
-    return "HslHueEXT";
-  case BlendOp::eHslSaturationEXT:
-    return "HslSaturationEXT";
-  case BlendOp::eHslColorEXT:
-    return "HslColorEXT";
-  case BlendOp::eHslLuminosityEXT:
-    return "HslLuminosityEXT";
-  case BlendOp::ePlusEXT:
-    return "PlusEXT";
-  case BlendOp::ePlusClampedEXT:
-    return "PlusClampedEXT";
-  case BlendOp::ePlusClampedAlphaEXT:
-    return "PlusClampedAlphaEXT";
-  case BlendOp::ePlusDarkerEXT:
-    return "PlusDarkerEXT";
-  case BlendOp::eMinusEXT:
-    return "MinusEXT";
-  case BlendOp::eMinusClampedEXT:
-    return "MinusClampedEXT";
-  case BlendOp::eContrastEXT:
-    return "ContrastEXT";
-  case BlendOp::eInvertOvgEXT:
-    return "InvertOvgEXT";
-  case BlendOp::eRedEXT:
-    return "RedEXT";
-  case BlendOp::eGreenEXT:
-    return "GreenEXT";
-  case BlendOp::eBlueEXT:
-    return "BlueEXT";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class BlendOverlapEXT {
-  eUncorrelated = VK_BLEND_OVERLAP_UNCORRELATED_EXT,
-  eDisjoint = VK_BLEND_OVERLAP_DISJOINT_EXT,
-  eConjoint = VK_BLEND_OVERLAP_CONJOINT_EXT
-};
-
-VULKAN_HPP_INLINE std::string to_string(BlendOverlapEXT value) {
-  switch (value) {
-  case BlendOverlapEXT::eUncorrelated:
-    return "Uncorrelated";
-  case BlendOverlapEXT::eDisjoint:
-    return "Disjoint";
-  case BlendOverlapEXT::eConjoint:
-    return "Conjoint";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class BorderColor {
-  eFloatTransparentBlack = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,
-  eIntTransparentBlack = VK_BORDER_COLOR_INT_TRANSPARENT_BLACK,
-  eFloatOpaqueBlack = VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK,
-  eIntOpaqueBlack = VK_BORDER_COLOR_INT_OPAQUE_BLACK,
-  eFloatOpaqueWhite = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE,
-  eIntOpaqueWhite = VK_BORDER_COLOR_INT_OPAQUE_WHITE,
-  eFloatCustomEXT = VK_BORDER_COLOR_FLOAT_CUSTOM_EXT,
-  eIntCustomEXT = VK_BORDER_COLOR_INT_CUSTOM_EXT
-};
-
-VULKAN_HPP_INLINE std::string to_string(BorderColor value) {
-  switch (value) {
-  case BorderColor::eFloatTransparentBlack:
-    return "FloatTransparentBlack";
-  case BorderColor::eIntTransparentBlack:
-    return "IntTransparentBlack";
-  case BorderColor::eFloatOpaqueBlack:
-    return "FloatOpaqueBlack";
-  case BorderColor::eIntOpaqueBlack:
-    return "IntOpaqueBlack";
-  case BorderColor::eFloatOpaqueWhite:
-    return "FloatOpaqueWhite";
-  case BorderColor::eIntOpaqueWhite:
-    return "IntOpaqueWhite";
-  case BorderColor::eFloatCustomEXT:
-    return "FloatCustomEXT";
-  case BorderColor::eIntCustomEXT:
-    return "IntCustomEXT";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class BufferCreateFlagBits : VkBufferCreateFlags {
-  eSparseBinding = VK_BUFFER_CREATE_SPARSE_BINDING_BIT,
-  eSparseResidency = VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT,
-  eSparseAliased = VK_BUFFER_CREATE_SPARSE_ALIASED_BIT,
-  eProtected = VK_BUFFER_CREATE_PROTECTED_BIT,
-  eDeviceAddressCaptureReplay =
-      VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT,
-  eDeviceAddressCaptureReplayEXT =
-      VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT,
-  eDeviceAddressCaptureReplayKHR =
-      VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR
-};
-
-VULKAN_HPP_INLINE std::string to_string(BufferCreateFlagBits value) {
-  switch (value) {
-  case BufferCreateFlagBits::eSparseBinding:
-    return "SparseBinding";
-  case BufferCreateFlagBits::eSparseResidency:
-    return "SparseResidency";
-  case BufferCreateFlagBits::eSparseAliased:
-    return "SparseAliased";
-  case BufferCreateFlagBits::eProtected:
-    return "Protected";
-  case BufferCreateFlagBits::eDeviceAddressCaptureReplay:
-    return "DeviceAddressCaptureReplay";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class BufferUsageFlagBits : VkBufferUsageFlags {
-  eTransferSrc = VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
-  eTransferDst = VK_BUFFER_USAGE_TRANSFER_DST_BIT,
-  eUniformTexelBuffer = VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT,
-  eStorageTexelBuffer = VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT,
-  eUniformBuffer = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
-  eStorageBuffer = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT,
-  eIndexBuffer = VK_BUFFER_USAGE_INDEX_BUFFER_BIT,
-  eVertexBuffer = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
-  eIndirectBuffer = VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT,
-  eShaderDeviceAddress = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
-  eTransformFeedbackBufferEXT =
-      VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT,
-  eTransformFeedbackCounterBufferEXT =
-      VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT,
-  eConditionalRenderingEXT = VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT,
-  eAccelerationStructureBuildInputReadOnlyKHR =
-      VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR,
-  eAccelerationStructureStorageKHR =
-      VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR,
-  eShaderBindingTableKHR = VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR,
-  eRayTracingNV = VK_BUFFER_USAGE_RAY_TRACING_BIT_NV,
-  eShaderDeviceAddressEXT = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT,
-  eShaderDeviceAddressKHR = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR
-};
-
-VULKAN_HPP_INLINE std::string to_string(BufferUsageFlagBits value) {
-  switch (value) {
-  case BufferUsageFlagBits::eTransferSrc:
-    return "TransferSrc";
-  case BufferUsageFlagBits::eTransferDst:
-    return "TransferDst";
-  case BufferUsageFlagBits::eUniformTexelBuffer:
-    return "UniformTexelBuffer";
-  case BufferUsageFlagBits::eStorageTexelBuffer:
-    return "StorageTexelBuffer";
-  case BufferUsageFlagBits::eUniformBuffer:
-    return "UniformBuffer";
-  case BufferUsageFlagBits::eStorageBuffer:
-    return "StorageBuffer";
-  case BufferUsageFlagBits::eIndexBuffer:
-    return "IndexBuffer";
-  case BufferUsageFlagBits::eVertexBuffer:
-    return "VertexBuffer";
-  case BufferUsageFlagBits::eIndirectBuffer:
-    return "IndirectBuffer";
-  case BufferUsageFlagBits::eShaderDeviceAddress:
-    return "ShaderDeviceAddress";
-  case BufferUsageFlagBits::eTransformFeedbackBufferEXT:
-    return "TransformFeedbackBufferEXT";
-  case BufferUsageFlagBits::eTransformFeedbackCounterBufferEXT:
-    return "TransformFeedbackCounterBufferEXT";
-  case BufferUsageFlagBits::eConditionalRenderingEXT:
-    return "ConditionalRenderingEXT";
-  case BufferUsageFlagBits::eAccelerationStructureBuildInputReadOnlyKHR:
-    return "AccelerationStructureBuildInputReadOnlyKHR";
-  case BufferUsageFlagBits::eAccelerationStructureStorageKHR:
-    return "AccelerationStructureStorageKHR";
-  case BufferUsageFlagBits::eShaderBindingTableKHR:
-    return "ShaderBindingTableKHR";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class
-    BuildAccelerationStructureFlagBitsKHR : VkBuildAccelerationStructureFlagsKHR {
-      eAllowUpdate = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR,
-      eAllowCompaction =
-          VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR,
-      ePreferFastTrace =
-          VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR,
-      ePreferFastBuild =
-          VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR,
-      eLowMemory = VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR
-    };
-using BuildAccelerationStructureFlagBitsNV =
-    BuildAccelerationStructureFlagBitsKHR;
-
-VULKAN_HPP_INLINE std::string
-to_string(BuildAccelerationStructureFlagBitsKHR value) {
-  switch (value) {
-  case BuildAccelerationStructureFlagBitsKHR::eAllowUpdate:
-    return "AllowUpdate";
-  case BuildAccelerationStructureFlagBitsKHR::eAllowCompaction:
-    return "AllowCompaction";
-  case BuildAccelerationStructureFlagBitsKHR::ePreferFastTrace:
-    return "PreferFastTrace";
-  case BuildAccelerationStructureFlagBitsKHR::ePreferFastBuild:
-    return "PreferFastBuild";
-  case BuildAccelerationStructureFlagBitsKHR::eLowMemory:
-    return "LowMemory";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class BuildAccelerationStructureModeKHR {
-  eBuild = VK_BUILD_ACCELERATION_STRUCTURE_MODE_BUILD_KHR,
-  eUpdate = VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR
-};
-
-VULKAN_HPP_INLINE std::string
-to_string(BuildAccelerationStructureModeKHR value) {
-  switch (value) {
-  case BuildAccelerationStructureModeKHR::eBuild:
-    return "Build";
-  case BuildAccelerationStructureModeKHR::eUpdate:
-    return "Update";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class ChromaLocation {
-  eCositedEven = VK_CHROMA_LOCATION_COSITED_EVEN,
-  eMidpoint = VK_CHROMA_LOCATION_MIDPOINT
-};
-using ChromaLocationKHR = ChromaLocation;
-
-VULKAN_HPP_INLINE std::string to_string(ChromaLocation value) {
-  switch (value) {
-  case ChromaLocation::eCositedEven:
-    return "CositedEven";
-  case ChromaLocation::eMidpoint:
-    return "Midpoint";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class CoarseSampleOrderTypeNV {
-  eDefault = VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV,
-  eCustom = VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV,
-  ePixelMajor = VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV,
-  eSampleMajor = VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV
-};
-
-VULKAN_HPP_INLINE std::string to_string(CoarseSampleOrderTypeNV value) {
-  switch (value) {
-  case CoarseSampleOrderTypeNV::eDefault:
-    return "Default";
-  case CoarseSampleOrderTypeNV::eCustom:
-    return "Custom";
-  case CoarseSampleOrderTypeNV::ePixelMajor:
-    return "PixelMajor";
-  case CoarseSampleOrderTypeNV::eSampleMajor:
-    return "SampleMajor";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class ColorComponentFlagBits : VkColorComponentFlags {
-  eR = VK_COLOR_COMPONENT_R_BIT,
-  eG = VK_COLOR_COMPONENT_G_BIT,
-  eB = VK_COLOR_COMPONENT_B_BIT,
-  eA = VK_COLOR_COMPONENT_A_BIT
-};
-
-VULKAN_HPP_INLINE std::string to_string(ColorComponentFlagBits value) {
-  switch (value) {
-  case ColorComponentFlagBits::eR:
-    return "R";
-  case ColorComponentFlagBits::eG:
-    return "G";
-  case ColorComponentFlagBits::eB:
-    return "B";
-  case ColorComponentFlagBits::eA:
-    return "A";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class ColorSpaceKHR {
-  eSrgbNonlinear = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR,
-  eDisplayP3NonlinearEXT = VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT,
-  eExtendedSrgbLinearEXT = VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT,
-  eDisplayP3LinearEXT = VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT,
-  eDciP3NonlinearEXT = VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT,
-  eBt709LinearEXT = VK_COLOR_SPACE_BT709_LINEAR_EXT,
-  eBt709NonlinearEXT = VK_COLOR_SPACE_BT709_NONLINEAR_EXT,
-  eBt2020LinearEXT = VK_COLOR_SPACE_BT2020_LINEAR_EXT,
-  eHdr10St2084EXT = VK_COLOR_SPACE_HDR10_ST2084_EXT,
-  eDolbyvisionEXT = VK_COLOR_SPACE_DOLBYVISION_EXT,
-  eHdr10HlgEXT = VK_COLOR_SPACE_HDR10_HLG_EXT,
-  eAdobergbLinearEXT = VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT,
-  eAdobergbNonlinearEXT = VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT,
-  ePassThroughEXT = VK_COLOR_SPACE_PASS_THROUGH_EXT,
-  eExtendedSrgbNonlinearEXT = VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT,
-  eDisplayNativeAMD = VK_COLOR_SPACE_DISPLAY_NATIVE_AMD,
-  eVkColorspaceSrgbNonlinear = VK_COLORSPACE_SRGB_NONLINEAR_KHR,
-  eDciP3LinearEXT = VK_COLOR_SPACE_DCI_P3_LINEAR_EXT
-};
-
-VULKAN_HPP_INLINE std::string to_string(ColorSpaceKHR value) {
-  switch (value) {
-  case ColorSpaceKHR::eSrgbNonlinear:
-    return "SrgbNonlinear";
-  case ColorSpaceKHR::eDisplayP3NonlinearEXT:
-    return "DisplayP3NonlinearEXT";
-  case ColorSpaceKHR::eExtendedSrgbLinearEXT:
-    return "ExtendedSrgbLinearEXT";
-  case ColorSpaceKHR::eDisplayP3LinearEXT:
-    return "DisplayP3LinearEXT";
-  case ColorSpaceKHR::eDciP3NonlinearEXT:
-    return "DciP3NonlinearEXT";
-  case ColorSpaceKHR::eBt709LinearEXT:
-    return "Bt709LinearEXT";
-  case ColorSpaceKHR::eBt709NonlinearEXT:
-    return "Bt709NonlinearEXT";
-  case ColorSpaceKHR::eBt2020LinearEXT:
-    return "Bt2020LinearEXT";
-  case ColorSpaceKHR::eHdr10St2084EXT:
-    return "Hdr10St2084EXT";
-  case ColorSpaceKHR::eDolbyvisionEXT:
-    return "DolbyvisionEXT";
-  case ColorSpaceKHR::eHdr10HlgEXT:
-    return "Hdr10HlgEXT";
-  case ColorSpaceKHR::eAdobergbLinearEXT:
-    return "AdobergbLinearEXT";
-  case ColorSpaceKHR::eAdobergbNonlinearEXT:
-    return "AdobergbNonlinearEXT";
-  case ColorSpaceKHR::ePassThroughEXT:
-    return "PassThroughEXT";
-  case ColorSpaceKHR::eExtendedSrgbNonlinearEXT:
-    return "ExtendedSrgbNonlinearEXT";
-  case ColorSpaceKHR::eDisplayNativeAMD:
-    return "DisplayNativeAMD";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class CommandBufferLevel {
-  ePrimary = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
-  eSecondary = VK_COMMAND_BUFFER_LEVEL_SECONDARY
-};
-
-VULKAN_HPP_INLINE std::string to_string(CommandBufferLevel value) {
-  switch (value) {
-  case CommandBufferLevel::ePrimary:
-    return "Primary";
-  case CommandBufferLevel::eSecondary:
-    return "Secondary";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class CommandBufferResetFlagBits : VkCommandBufferResetFlags {
-  eReleaseResources = VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT
-};
-
-VULKAN_HPP_INLINE std::string to_string(CommandBufferResetFlagBits value) {
-  switch (value) {
-  case CommandBufferResetFlagBits::eReleaseResources:
-    return "ReleaseResources";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class CommandBufferUsageFlagBits : VkCommandBufferUsageFlags {
-  eOneTimeSubmit = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
-  eRenderPassContinue = VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT,
-  eSimultaneousUse = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT
-};
-
-VULKAN_HPP_INLINE std::string to_string(CommandBufferUsageFlagBits value) {
-  switch (value) {
-  case CommandBufferUsageFlagBits::eOneTimeSubmit:
-    return "OneTimeSubmit";
-  case CommandBufferUsageFlagBits::eRenderPassContinue:
-    return "RenderPassContinue";
-  case CommandBufferUsageFlagBits::eSimultaneousUse:
-    return "SimultaneousUse";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class CommandPoolCreateFlagBits : VkCommandPoolCreateFlags {
-  eTransient = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT,
-  eResetCommandBuffer = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,
-  eProtected = VK_COMMAND_POOL_CREATE_PROTECTED_BIT
-};
-
-VULKAN_HPP_INLINE std::string to_string(CommandPoolCreateFlagBits value) {
-  switch (value) {
-  case CommandPoolCreateFlagBits::eTransient:
-    return "Transient";
-  case CommandPoolCreateFlagBits::eResetCommandBuffer:
-    return "ResetCommandBuffer";
-  case CommandPoolCreateFlagBits::eProtected:
-    return "Protected";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class CommandPoolResetFlagBits : VkCommandPoolResetFlags {
-  eReleaseResources = VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT
-};
-
-VULKAN_HPP_INLINE std::string to_string(CommandPoolResetFlagBits value) {
-  switch (value) {
-  case CommandPoolResetFlagBits::eReleaseResources:
-    return "ReleaseResources";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class CompareOp {
-  eNever = VK_COMPARE_OP_NEVER,
-  eLess = VK_COMPARE_OP_LESS,
-  eEqual = VK_COMPARE_OP_EQUAL,
-  eLessOrEqual = VK_COMPARE_OP_LESS_OR_EQUAL,
-  eGreater = VK_COMPARE_OP_GREATER,
-  eNotEqual = VK_COMPARE_OP_NOT_EQUAL,
-  eGreaterOrEqual = VK_COMPARE_OP_GREATER_OR_EQUAL,
-  eAlways = VK_COMPARE_OP_ALWAYS
-};
-
-VULKAN_HPP_INLINE std::string to_string(CompareOp value) {
-  switch (value) {
-  case CompareOp::eNever:
-    return "Never";
-  case CompareOp::eLess:
-    return "Less";
-  case CompareOp::eEqual:
-    return "Equal";
-  case CompareOp::eLessOrEqual:
-    return "LessOrEqual";
-  case CompareOp::eGreater:
-    return "Greater";
-  case CompareOp::eNotEqual:
-    return "NotEqual";
-  case CompareOp::eGreaterOrEqual:
-    return "GreaterOrEqual";
-  case CompareOp::eAlways:
-    return "Always";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class ComponentSwizzle {
-  eIdentity = VK_COMPONENT_SWIZZLE_IDENTITY,
-  eZero = VK_COMPONENT_SWIZZLE_ZERO,
-  eOne = VK_COMPONENT_SWIZZLE_ONE,
-  eR = VK_COMPONENT_SWIZZLE_R,
-  eG = VK_COMPONENT_SWIZZLE_G,
-  eB = VK_COMPONENT_SWIZZLE_B,
-  eA = VK_COMPONENT_SWIZZLE_A
-};
-
-VULKAN_HPP_INLINE std::string to_string(ComponentSwizzle value) {
-  switch (value) {
-  case ComponentSwizzle::eIdentity:
-    return "Identity";
-  case ComponentSwizzle::eZero:
-    return "Zero";
-  case ComponentSwizzle::eOne:
-    return "One";
-  case ComponentSwizzle::eR:
-    return "R";
-  case ComponentSwizzle::eG:
-    return "G";
-  case ComponentSwizzle::eB:
-    return "B";
-  case ComponentSwizzle::eA:
-    return "A";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class ComponentTypeNV {
-  eFloat16 = VK_COMPONENT_TYPE_FLOAT16_NV,
-  eFloat32 = VK_COMPONENT_TYPE_FLOAT32_NV,
-  eFloat64 = VK_COMPONENT_TYPE_FLOAT64_NV,
-  eSint8 = VK_COMPONENT_TYPE_SINT8_NV,
-  eSint16 = VK_COMPONENT_TYPE_SINT16_NV,
-  eSint32 = VK_COMPONENT_TYPE_SINT32_NV,
-  eSint64 = VK_COMPONENT_TYPE_SINT64_NV,
-  eUint8 = VK_COMPONENT_TYPE_UINT8_NV,
-  eUint16 = VK_COMPONENT_TYPE_UINT16_NV,
-  eUint32 = VK_COMPONENT_TYPE_UINT32_NV,
-  eUint64 = VK_COMPONENT_TYPE_UINT64_NV
-};
-
-VULKAN_HPP_INLINE std::string to_string(ComponentTypeNV value) {
-  switch (value) {
-  case ComponentTypeNV::eFloat16:
-    return "Float16";
-  case ComponentTypeNV::eFloat32:
-    return "Float32";
-  case ComponentTypeNV::eFloat64:
-    return "Float64";
-  case ComponentTypeNV::eSint8:
-    return "Sint8";
-  case ComponentTypeNV::eSint16:
-    return "Sint16";
-  case ComponentTypeNV::eSint32:
-    return "Sint32";
-  case ComponentTypeNV::eSint64:
-    return "Sint64";
-  case ComponentTypeNV::eUint8:
-    return "Uint8";
-  case ComponentTypeNV::eUint16:
-    return "Uint16";
-  case ComponentTypeNV::eUint32:
-    return "Uint32";
-  case ComponentTypeNV::eUint64:
-    return "Uint64";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class CompositeAlphaFlagBitsKHR : VkCompositeAlphaFlagsKHR {
-  eOpaque = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR,
-  ePreMultiplied = VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR,
-  ePostMultiplied = VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR,
-  eInherit = VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR
-};
-
-VULKAN_HPP_INLINE std::string to_string(CompositeAlphaFlagBitsKHR value) {
-  switch (value) {
-  case CompositeAlphaFlagBitsKHR::eOpaque:
-    return "Opaque";
-  case CompositeAlphaFlagBitsKHR::ePreMultiplied:
-    return "PreMultiplied";
-  case CompositeAlphaFlagBitsKHR::ePostMultiplied:
-    return "PostMultiplied";
-  case CompositeAlphaFlagBitsKHR::eInherit:
-    return "Inherit";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class ConditionalRenderingFlagBitsEXT : VkConditionalRenderingFlagsEXT {
-  eInverted = VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT
-};
-
-VULKAN_HPP_INLINE std::string to_string(ConditionalRenderingFlagBitsEXT value) {
-  switch (value) {
-  case ConditionalRenderingFlagBitsEXT::eInverted:
-    return "Inverted";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class ConservativeRasterizationModeEXT {
-  eDisabled = VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT,
-  eOverestimate = VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT,
-  eUnderestimate = VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT
-};
-
-VULKAN_HPP_INLINE std::string
-to_string(ConservativeRasterizationModeEXT value) {
-  switch (value) {
-  case ConservativeRasterizationModeEXT::eDisabled:
-    return "Disabled";
-  case ConservativeRasterizationModeEXT::eOverestimate:
-    return "Overestimate";
-  case ConservativeRasterizationModeEXT::eUnderestimate:
-    return "Underestimate";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class CopyAccelerationStructureModeKHR {
-  eClone = VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR,
-  eCompact = VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR,
-  eSerialize = VK_COPY_ACCELERATION_STRUCTURE_MODE_SERIALIZE_KHR,
-  eDeserialize = VK_COPY_ACCELERATION_STRUCTURE_MODE_DESERIALIZE_KHR
-};
-using CopyAccelerationStructureModeNV = CopyAccelerationStructureModeKHR;
-
-VULKAN_HPP_INLINE std::string
-to_string(CopyAccelerationStructureModeKHR value) {
-  switch (value) {
-  case CopyAccelerationStructureModeKHR::eClone:
-    return "Clone";
-  case CopyAccelerationStructureModeKHR::eCompact:
-    return "Compact";
-  case CopyAccelerationStructureModeKHR::eSerialize:
-    return "Serialize";
-  case CopyAccelerationStructureModeKHR::eDeserialize:
-    return "Deserialize";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class CoverageModulationModeNV {
-  eNone = VK_COVERAGE_MODULATION_MODE_NONE_NV,
-  eRgb = VK_COVERAGE_MODULATION_MODE_RGB_NV,
-  eAlpha = VK_COVERAGE_MODULATION_MODE_ALPHA_NV,
-  eRgba = VK_COVERAGE_MODULATION_MODE_RGBA_NV
-};
-
-VULKAN_HPP_INLINE std::string to_string(CoverageModulationModeNV value) {
-  switch (value) {
-  case CoverageModulationModeNV::eNone:
-    return "None";
-  case CoverageModulationModeNV::eRgb:
-    return "Rgb";
-  case CoverageModulationModeNV::eAlpha:
-    return "Alpha";
-  case CoverageModulationModeNV::eRgba:
-    return "Rgba";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class CoverageReductionModeNV {
-  eMerge = VK_COVERAGE_REDUCTION_MODE_MERGE_NV,
-  eTruncate = VK_COVERAGE_REDUCTION_MODE_TRUNCATE_NV
-};
-
-VULKAN_HPP_INLINE std::string to_string(CoverageReductionModeNV value) {
-  switch (value) {
-  case CoverageReductionModeNV::eMerge:
-    return "Merge";
-  case CoverageReductionModeNV::eTruncate:
-    return "Truncate";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class CullModeFlagBits : VkCullModeFlags {
-  eNone = VK_CULL_MODE_NONE,
-  eFront = VK_CULL_MODE_FRONT_BIT,
-  eBack = VK_CULL_MODE_BACK_BIT,
-  eFrontAndBack = VK_CULL_MODE_FRONT_AND_BACK
-};
-
-VULKAN_HPP_INLINE std::string to_string(CullModeFlagBits value) {
-  switch (value) {
-  case CullModeFlagBits::eNone:
-    return "None";
-  case CullModeFlagBits::eFront:
-    return "Front";
-  case CullModeFlagBits::eBack:
-    return "Back";
-  case CullModeFlagBits::eFrontAndBack:
-    return "FrontAndBack";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class DebugReportFlagBitsEXT : VkDebugReportFlagsEXT {
-  eInformation = VK_DEBUG_REPORT_INFORMATION_BIT_EXT,
-  eWarning = VK_DEBUG_REPORT_WARNING_BIT_EXT,
-  ePerformanceWarning = VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT,
-  eError = VK_DEBUG_REPORT_ERROR_BIT_EXT,
-  eDebug = VK_DEBUG_REPORT_DEBUG_BIT_EXT
-};
-
-VULKAN_HPP_INLINE std::string to_string(DebugReportFlagBitsEXT value) {
-  switch (value) {
-  case DebugReportFlagBitsEXT::eInformation:
-    return "Information";
-  case DebugReportFlagBitsEXT::eWarning:
-    return "Warning";
-  case DebugReportFlagBitsEXT::ePerformanceWarning:
-    return "PerformanceWarning";
-  case DebugReportFlagBitsEXT::eError:
-    return "Error";
-  case DebugReportFlagBitsEXT::eDebug:
-    return "Debug";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class DebugReportObjectTypeEXT {
-  // clang-format off
-      eUnknown = VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT
-    , eInstance = VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT
-    , ePhysicalDevice = VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT
-    , eDevice = VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT
-    , eQueue = VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT
-    , eSemaphore = VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT
-    , eCommandBuffer = VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT
-    , eFence = VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT
-    , eDeviceMemory = VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT
-    , eBuffer = VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT
-    , eImage = VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT
-    , eEvent = VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT
-    , eQueryPool = VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT
-    , eBufferView = VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT
-    , eImageView = VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT
-    , eShaderModule = VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT
-    , ePipelineCache = VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT
-    , ePipelineLayout = VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT
-    , eRenderPass = VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT
-    , ePipeline = VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT
-    , eDescriptorSetLayout = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT
-    , eSampler = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT
-    , eDescriptorPool = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT
-    , eDescriptorSet = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT
-    , eFramebuffer = VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT
-    , eCommandPool = VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT
-    , eSurfaceKHR = VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT
-    , eSwapchainKHR = VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT
-    , eDebugReportCallbackEXT = VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT
-    , eDisplayKHR = VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT
-    , eDisplayModeKHR = VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT
-    , eValidationCacheEXT = VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT
-    , eSamplerYcbcrConversion = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT
-    , eDescriptorUpdateTemplate = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT
-    , eAccelerationStructureKHR = VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR_EXT
-    , eAccelerationStructureNV = VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT
-#if defined( VK_USE_PLATFORM_FUCHSIA )
-    , eBufferCollectionFUCHSIA = VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA_EXT
-#endif /*VK_USE_PLATFORM_FUCHSIA*/
-    , eDebugReport = VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT
-    , eDescriptorUpdateTemplateKHR = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT
-    , eSamplerYcbcrConversionKHR = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR_EXT
-    , eValidationCache = VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT
-  // clang-format on
-};
-
-VULKAN_HPP_INLINE std::string to_string(DebugReportObjectTypeEXT value) {
-  switch (value) {
-  case DebugReportObjectTypeEXT::eUnknown:
-    return "Unknown";
-  case DebugReportObjectTypeEXT::eInstance:
-    return "Instance";
-  case DebugReportObjectTypeEXT::ePhysicalDevice:
-    return "PhysicalDevice";
-  case DebugReportObjectTypeEXT::eDevice:
-    return "Device";
-  case DebugReportObjectTypeEXT::eQueue:
-    return "Queue";
-  case DebugReportObjectTypeEXT::eSemaphore:
-    return "Semaphore";
-  case DebugReportObjectTypeEXT::eCommandBuffer:
-    return "CommandBuffer";
-  case DebugReportObjectTypeEXT::eFence:
-    return "Fence";
-  case DebugReportObjectTypeEXT::eDeviceMemory:
-    return "DeviceMemory";
-  case DebugReportObjectTypeEXT::eBuffer:
-    return "Buffer";
-  case DebugReportObjectTypeEXT::eImage:
-    return "Image";
-  case DebugReportObjectTypeEXT::eEvent:
-    return "Event";
-  case DebugReportObjectTypeEXT::eQueryPool:
-    return "QueryPool";
-  case DebugReportObjectTypeEXT::eBufferView:
-    return "BufferView";
-  case DebugReportObjectTypeEXT::eImageView:
-    return "ImageView";
-  case DebugReportObjectTypeEXT::eShaderModule:
-    return "ShaderModule";
-  case DebugReportObjectTypeEXT::ePipelineCache:
-    return "PipelineCache";
-  case DebugReportObjectTypeEXT::ePipelineLayout:
-    return "PipelineLayout";
-  case DebugReportObjectTypeEXT::eRenderPass:
-    return "RenderPass";
-  case DebugReportObjectTypeEXT::ePipeline:
-    return "Pipeline";
-  case DebugReportObjectTypeEXT::eDescriptorSetLayout:
-    return "DescriptorSetLayout";
-  case DebugReportObjectTypeEXT::eSampler:
-    return "Sampler";
-  case DebugReportObjectTypeEXT::eDescriptorPool:
-    return "DescriptorPool";
-  case DebugReportObjectTypeEXT::eDescriptorSet:
-    return "DescriptorSet";
-  case DebugReportObjectTypeEXT::eFramebuffer:
-    return "Framebuffer";
-  case DebugReportObjectTypeEXT::eCommandPool:
-    return "CommandPool";
-  case DebugReportObjectTypeEXT::eSurfaceKHR:
-    return "SurfaceKHR";
-  case DebugReportObjectTypeEXT::eSwapchainKHR:
-    return "SwapchainKHR";
-  case DebugReportObjectTypeEXT::eDebugReportCallbackEXT:
-    return "DebugReportCallbackEXT";
-  case DebugReportObjectTypeEXT::eDisplayKHR:
-    return "DisplayKHR";
-  case DebugReportObjectTypeEXT::eDisplayModeKHR:
-    return "DisplayModeKHR";
-  case DebugReportObjectTypeEXT::eValidationCacheEXT:
-    return "ValidationCacheEXT";
-  case DebugReportObjectTypeEXT::eSamplerYcbcrConversion:
-    return "SamplerYcbcrConversion";
-  case DebugReportObjectTypeEXT::eDescriptorUpdateTemplate:
-    return "DescriptorUpdateTemplate";
-  case DebugReportObjectTypeEXT::eAccelerationStructureKHR:
-    return "AccelerationStructureKHR";
-  case DebugReportObjectTypeEXT::eAccelerationStructureNV:
-    return "AccelerationStructureNV";
-#if defined(VK_USE_PLATFORM_FUCHSIA)
-  case DebugReportObjectTypeEXT::eBufferCollectionFUCHSIA:
-    return "BufferCollectionFUCHSIA";
-#endif /*VK_USE_PLATFORM_FUCHSIA*/
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class
-    DebugUtilsMessageSeverityFlagBitsEXT : VkDebugUtilsMessageSeverityFlagsEXT {
-      eVerbose = VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT,
-      eInfo = VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT,
-      eWarning = VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT,
-      eError = VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT
-    };
-
-VULKAN_HPP_INLINE std::string
-to_string(DebugUtilsMessageSeverityFlagBitsEXT value) {
-  switch (value) {
-  case DebugUtilsMessageSeverityFlagBitsEXT::eVerbose:
-    return "Verbose";
-  case DebugUtilsMessageSeverityFlagBitsEXT::eInfo:
-    return "Info";
-  case DebugUtilsMessageSeverityFlagBitsEXT::eWarning:
-    return "Warning";
-  case DebugUtilsMessageSeverityFlagBitsEXT::eError:
-    return "Error";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class DebugUtilsMessageTypeFlagBitsEXT : VkDebugUtilsMessageTypeFlagsEXT {
-  eGeneral = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT,
-  eValidation = VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT,
-  ePerformance = VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT
-};
-
-VULKAN_HPP_INLINE std::string
-to_string(DebugUtilsMessageTypeFlagBitsEXT value) {
-  switch (value) {
-  case DebugUtilsMessageTypeFlagBitsEXT::eGeneral:
-    return "General";
-  case DebugUtilsMessageTypeFlagBitsEXT::eValidation:
-    return "Validation";
-  case DebugUtilsMessageTypeFlagBitsEXT::ePerformance:
-    return "Performance";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class DependencyFlagBits : VkDependencyFlags {
-  eByRegion = VK_DEPENDENCY_BY_REGION_BIT,
-  eDeviceGroup = VK_DEPENDENCY_DEVICE_GROUP_BIT,
-  eViewLocal = VK_DEPENDENCY_VIEW_LOCAL_BIT,
-  eDeviceGroupKHR = VK_DEPENDENCY_DEVICE_GROUP_BIT_KHR,
-  eViewLocalKHR = VK_DEPENDENCY_VIEW_LOCAL_BIT_KHR
-};
-
-VULKAN_HPP_INLINE std::string to_string(DependencyFlagBits value) {
-  switch (value) {
-  case DependencyFlagBits::eByRegion:
-    return "ByRegion";
-  case DependencyFlagBits::eDeviceGroup:
-    return "DeviceGroup";
-  case DependencyFlagBits::eViewLocal:
-    return "ViewLocal";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class DescriptorBindingFlagBits : VkDescriptorBindingFlags {
-  eUpdateAfterBind = VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT,
-  eUpdateUnusedWhilePending =
-      VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT,
-  ePartiallyBound = VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT,
-  eVariableDescriptorCount = VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT
-};
-using DescriptorBindingFlagBitsEXT = DescriptorBindingFlagBits;
-
-VULKAN_HPP_INLINE std::string to_string(DescriptorBindingFlagBits value) {
-  switch (value) {
-  case DescriptorBindingFlagBits::eUpdateAfterBind:
-    return "UpdateAfterBind";
-  case DescriptorBindingFlagBits::eUpdateUnusedWhilePending:
-    return "UpdateUnusedWhilePending";
-  case DescriptorBindingFlagBits::ePartiallyBound:
-    return "PartiallyBound";
-  case DescriptorBindingFlagBits::eVariableDescriptorCount:
-    return "VariableDescriptorCount";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class DescriptorPoolCreateFlagBits : VkDescriptorPoolCreateFlags {
-  eFreeDescriptorSet = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT,
-  eUpdateAfterBind = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT,
-  eHostOnlyVALVE = VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE,
-  eUpdateAfterBindEXT = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT
-};
-
-VULKAN_HPP_INLINE std::string to_string(DescriptorPoolCreateFlagBits value) {
-  switch (value) {
-  case DescriptorPoolCreateFlagBits::eFreeDescriptorSet:
-    return "FreeDescriptorSet";
-  case DescriptorPoolCreateFlagBits::eUpdateAfterBind:
-    return "UpdateAfterBind";
-  case DescriptorPoolCreateFlagBits::eHostOnlyVALVE:
-    return "HostOnlyVALVE";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class
-    DescriptorSetLayoutCreateFlagBits : VkDescriptorSetLayoutCreateFlags {
-      eUpdateAfterBindPool =
-          VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT,
-      ePushDescriptorKHR =
-          VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR,
-      eHostOnlyPoolVALVE =
-          VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE,
-      eUpdateAfterBindPoolEXT =
-          VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT
-    };
-
-VULKAN_HPP_INLINE std::string
-to_string(DescriptorSetLayoutCreateFlagBits value) {
-  switch (value) {
-  case DescriptorSetLayoutCreateFlagBits::eUpdateAfterBindPool:
-    return "UpdateAfterBindPool";
-  case DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR:
-    return "PushDescriptorKHR";
-  case DescriptorSetLayoutCreateFlagBits::eHostOnlyPoolVALVE:
-    return "HostOnlyPoolVALVE";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class DescriptorType {
-  eSampler = VK_DESCRIPTOR_TYPE_SAMPLER,
-  eCombinedImageSampler = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
-  eSampledImage = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
-  eStorageImage = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
-  eUniformTexelBuffer = VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER,
-  eStorageTexelBuffer = VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER,
-  eUniformBuffer = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
-  eStorageBuffer = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
-  eUniformBufferDynamic = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC,
-  eStorageBufferDynamic = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC,
-  eInputAttachment = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
-  eInlineUniformBlockEXT = VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT,
-  eAccelerationStructureKHR = VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR,
-  eAccelerationStructureNV = VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV,
-  eMutableVALVE = VK_DESCRIPTOR_TYPE_MUTABLE_VALVE
-};
-
-VULKAN_HPP_INLINE std::string to_string(DescriptorType value) {
-  switch (value) {
-  case DescriptorType::eSampler:
-    return "Sampler";
-  case DescriptorType::eCombinedImageSampler:
-    return "CombinedImageSampler";
-  case DescriptorType::eSampledImage:
-    return "SampledImage";
-  case DescriptorType::eStorageImage:
-    return "StorageImage";
-  case DescriptorType::eUniformTexelBuffer:
-    return "UniformTexelBuffer";
-  case DescriptorType::eStorageTexelBuffer:
-    return "StorageTexelBuffer";
-  case DescriptorType::eUniformBuffer:
-    return "UniformBuffer";
-  case DescriptorType::eStorageBuffer:
-    return "StorageBuffer";
-  case DescriptorType::eUniformBufferDynamic:
-    return "UniformBufferDynamic";
-  case DescriptorType::eStorageBufferDynamic:
-    return "StorageBufferDynamic";
-  case DescriptorType::eInputAttachment:
-    return "InputAttachment";
-  case DescriptorType::eInlineUniformBlockEXT:
-    return "InlineUniformBlockEXT";
-  case DescriptorType::eAccelerationStructureKHR:
-    return "AccelerationStructureKHR";
-  case DescriptorType::eAccelerationStructureNV:
-    return "AccelerationStructureNV";
-  case DescriptorType::eMutableVALVE:
-    return "MutableVALVE";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class DescriptorUpdateTemplateType {
-  eDescriptorSet = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET,
-  ePushDescriptorsKHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR
-};
-using DescriptorUpdateTemplateTypeKHR = DescriptorUpdateTemplateType;
-
-VULKAN_HPP_INLINE std::string to_string(DescriptorUpdateTemplateType value) {
-  switch (value) {
-  case DescriptorUpdateTemplateType::eDescriptorSet:
-    return "DescriptorSet";
-  case DescriptorUpdateTemplateType::ePushDescriptorsKHR:
-    return "PushDescriptorsKHR";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class DeviceCreateFlagBits {};
-
-VULKAN_HPP_INLINE std::string to_string(DeviceCreateFlagBits) {
-  return "(void)";
-}
-
-enum class
-    DeviceDiagnosticsConfigFlagBitsNV : VkDeviceDiagnosticsConfigFlagsNV {
-      eEnableShaderDebugInfo =
-          VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_DEBUG_INFO_BIT_NV,
-      eEnableResourceTracking =
-          VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_RESOURCE_TRACKING_BIT_NV,
-      eEnableAutomaticCheckpoints =
-          VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_AUTOMATIC_CHECKPOINTS_BIT_NV
-    };
-
-VULKAN_HPP_INLINE std::string
-to_string(DeviceDiagnosticsConfigFlagBitsNV value) {
-  switch (value) {
-  case DeviceDiagnosticsConfigFlagBitsNV::eEnableShaderDebugInfo:
-    return "EnableShaderDebugInfo";
-  case DeviceDiagnosticsConfigFlagBitsNV::eEnableResourceTracking:
-    return "EnableResourceTracking";
-  case DeviceDiagnosticsConfigFlagBitsNV::eEnableAutomaticCheckpoints:
-    return "EnableAutomaticCheckpoints";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class DeviceEventTypeEXT {
-  eDisplayHotplug = VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT
-};
-
-VULKAN_HPP_INLINE std::string to_string(DeviceEventTypeEXT value) {
-  switch (value) {
-  case DeviceEventTypeEXT::eDisplayHotplug:
-    return "DisplayHotplug";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class
-    DeviceGroupPresentModeFlagBitsKHR : VkDeviceGroupPresentModeFlagsKHR {
-      eLocal = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR,
-      eRemote = VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR,
-      eSum = VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR,
-      eLocalMultiDevice =
-          VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR
-    };
-
-VULKAN_HPP_INLINE std::string
-to_string(DeviceGroupPresentModeFlagBitsKHR value) {
-  switch (value) {
-  case DeviceGroupPresentModeFlagBitsKHR::eLocal:
-    return "Local";
-  case DeviceGroupPresentModeFlagBitsKHR::eRemote:
-    return "Remote";
-  case DeviceGroupPresentModeFlagBitsKHR::eSum:
-    return "Sum";
-  case DeviceGroupPresentModeFlagBitsKHR::eLocalMultiDevice:
-    return "LocalMultiDevice";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class DeviceMemoryReportEventTypeEXT {
-  eAllocate = VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATE_EXT,
-  eFree = VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_FREE_EXT,
-  eImport = VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_IMPORT_EXT,
-  eUnimport = VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_UNIMPORT_EXT,
-  eAllocationFailed = VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATION_FAILED_EXT
-};
-
-VULKAN_HPP_INLINE std::string to_string(DeviceMemoryReportEventTypeEXT value) {
-  switch (value) {
-  case DeviceMemoryReportEventTypeEXT::eAllocate:
-    return "Allocate";
-  case DeviceMemoryReportEventTypeEXT::eFree:
-    return "Free";
-  case DeviceMemoryReportEventTypeEXT::eImport:
-    return "Import";
-  case DeviceMemoryReportEventTypeEXT::eUnimport:
-    return "Unimport";
-  case DeviceMemoryReportEventTypeEXT::eAllocationFailed:
-    return "AllocationFailed";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class DeviceQueueCreateFlagBits : VkDeviceQueueCreateFlags {
-  eProtected = VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT
-};
-
-VULKAN_HPP_INLINE std::string to_string(DeviceQueueCreateFlagBits value) {
-  switch (value) {
-  case DeviceQueueCreateFlagBits::eProtected:
-    return "Protected";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class DiscardRectangleModeEXT {
-  eInclusive = VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT,
-  eExclusive = VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT
-};
-
-VULKAN_HPP_INLINE std::string to_string(DiscardRectangleModeEXT value) {
-  switch (value) {
-  case DiscardRectangleModeEXT::eInclusive:
-    return "Inclusive";
-  case DiscardRectangleModeEXT::eExclusive:
-    return "Exclusive";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class DisplayEventTypeEXT {
-  eFirstPixelOut = VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT
-};
-
-VULKAN_HPP_INLINE std::string to_string(DisplayEventTypeEXT value) {
-  switch (value) {
-  case DisplayEventTypeEXT::eFirstPixelOut:
-    return "FirstPixelOut";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class DisplayPlaneAlphaFlagBitsKHR : VkDisplayPlaneAlphaFlagsKHR {
-  eOpaque = VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR,
-  eGlobal = VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR,
-  ePerPixel = VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR,
-  ePerPixelPremultiplied =
-      VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR
-};
-
-VULKAN_HPP_INLINE std::string to_string(DisplayPlaneAlphaFlagBitsKHR value) {
-  switch (value) {
-  case DisplayPlaneAlphaFlagBitsKHR::eOpaque:
-    return "Opaque";
-  case DisplayPlaneAlphaFlagBitsKHR::eGlobal:
-    return "Global";
-  case DisplayPlaneAlphaFlagBitsKHR::ePerPixel:
-    return "PerPixel";
-  case DisplayPlaneAlphaFlagBitsKHR::ePerPixelPremultiplied:
-    return "PerPixelPremultiplied";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class DisplayPowerStateEXT {
-  eOff = VK_DISPLAY_POWER_STATE_OFF_EXT,
-  eSuspend = VK_DISPLAY_POWER_STATE_SUSPEND_EXT,
-  eOn = VK_DISPLAY_POWER_STATE_ON_EXT
-};
-
-VULKAN_HPP_INLINE std::string to_string(DisplayPowerStateEXT value) {
-  switch (value) {
-  case DisplayPowerStateEXT::eOff:
-    return "Off";
-  case DisplayPowerStateEXT::eSuspend:
-    return "Suspend";
-  case DisplayPowerStateEXT::eOn:
-    return "On";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class DriverId {
-  eAmdProprietary = VK_DRIVER_ID_AMD_PROPRIETARY,
-  eAmdOpenSource = VK_DRIVER_ID_AMD_OPEN_SOURCE,
-  eMesaRadv = VK_DRIVER_ID_MESA_RADV,
-  eNvidiaProprietary = VK_DRIVER_ID_NVIDIA_PROPRIETARY,
-  eIntelProprietaryWindows = VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS,
-  eIntelOpenSourceMESA = VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA,
-  eImaginationProprietary = VK_DRIVER_ID_IMAGINATION_PROPRIETARY,
-  eQualcommProprietary = VK_DRIVER_ID_QUALCOMM_PROPRIETARY,
-  eArmProprietary = VK_DRIVER_ID_ARM_PROPRIETARY,
-  eGoogleSwiftshader = VK_DRIVER_ID_GOOGLE_SWIFTSHADER,
-  eGgpProprietary = VK_DRIVER_ID_GGP_PROPRIETARY,
-  eBroadcomProprietary = VK_DRIVER_ID_BROADCOM_PROPRIETARY,
-  eMesaLlvmpipe = VK_DRIVER_ID_MESA_LLVMPIPE,
-  eMoltenvk = VK_DRIVER_ID_MOLTENVK,
-  eIntelOpenSourceMesa = VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA_KHR
-};
-using DriverIdKHR = DriverId;
-
-VULKAN_HPP_INLINE std::string to_string(DriverId value) {
-  switch (value) {
-  case DriverId::eAmdProprietary:
-    return "AmdProprietary";
-  case DriverId::eAmdOpenSource:
-    return "AmdOpenSource";
-  case DriverId::eMesaRadv:
-    return "MesaRadv";
-  case DriverId::eNvidiaProprietary:
-    return "NvidiaProprietary";
-  case DriverId::eIntelProprietaryWindows:
-    return "IntelProprietaryWindows";
-  case DriverId::eIntelOpenSourceMESA:
-    return "IntelOpenSourceMESA";
-  case DriverId::eImaginationProprietary:
-    return "ImaginationProprietary";
-  case DriverId::eQualcommProprietary:
-    return "QualcommProprietary";
-  case DriverId::eArmProprietary:
-    return "ArmProprietary";
-  case DriverId::eGoogleSwiftshader:
-    return "GoogleSwiftshader";
-  case DriverId::eGgpProprietary:
-    return "GgpProprietary";
-  case DriverId::eBroadcomProprietary:
-    return "BroadcomProprietary";
-  case DriverId::eMesaLlvmpipe:
-    return "MesaLlvmpipe";
-  case DriverId::eMoltenvk:
-    return "Moltenvk";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class DynamicState {
-  eViewport = VK_DYNAMIC_STATE_VIEWPORT,
-  eScissor = VK_DYNAMIC_STATE_SCISSOR,
-  eLineWidth = VK_DYNAMIC_STATE_LINE_WIDTH,
-  eDepthBias = VK_DYNAMIC_STATE_DEPTH_BIAS,
-  eBlendConstants = VK_DYNAMIC_STATE_BLEND_CONSTANTS,
-  eDepthBounds = VK_DYNAMIC_STATE_DEPTH_BOUNDS,
-  eStencilCompareMask = VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK,
-  eStencilWriteMask = VK_DYNAMIC_STATE_STENCIL_WRITE_MASK,
-  eStencilReference = VK_DYNAMIC_STATE_STENCIL_REFERENCE,
-  eViewportWScalingNV = VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV,
-  eDiscardRectangleEXT = VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT,
-  eSampleLocationsEXT = VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT,
-  eRayTracingPipelineStackSizeKHR =
-      VK_DYNAMIC_STATE_RAY_TRACING_PIPELINE_STACK_SIZE_KHR,
-  eViewportShadingRatePaletteNV =
-      VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV,
-  eViewportCoarseSampleOrderNV =
-      VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV,
-  eExclusiveScissorNV = VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV,
-  eFragmentShadingRateKHR = VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR,
-  eLineStippleEXT = VK_DYNAMIC_STATE_LINE_STIPPLE_EXT,
-  eCullModeEXT = VK_DYNAMIC_STATE_CULL_MODE_EXT,
-  eFrontFaceEXT = VK_DYNAMIC_STATE_FRONT_FACE_EXT,
-  ePrimitiveTopologyEXT = VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT,
-  eViewportWithCountEXT = VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT,
-  eScissorWithCountEXT = VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT,
-  eVertexInputBindingStrideEXT =
-      VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT,
-  eDepthTestEnableEXT = VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE_EXT,
-  eDepthWriteEnableEXT = VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE_EXT,
-  eDepthCompareOpEXT = VK_DYNAMIC_STATE_DEPTH_COMPARE_OP_EXT,
-  eDepthBoundsTestEnableEXT = VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE_EXT,
-  eStencilTestEnableEXT = VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE_EXT,
-  eStencilOpEXT = VK_DYNAMIC_STATE_STENCIL_OP_EXT
-};
-
-VULKAN_HPP_INLINE std::string to_string(DynamicState value) {
-  switch (value) {
-  case DynamicState::eViewport:
-    return "Viewport";
-  case DynamicState::eScissor:
-    return "Scissor";
-  case DynamicState::eLineWidth:
-    return "LineWidth";
-  case DynamicState::eDepthBias:
-    return "DepthBias";
-  case DynamicState::eBlendConstants:
-    return "BlendConstants";
-  case DynamicState::eDepthBounds:
-    return "DepthBounds";
-  case DynamicState::eStencilCompareMask:
-    return "StencilCompareMask";
-  case DynamicState::eStencilWriteMask:
-    return "StencilWriteMask";
-  case DynamicState::eStencilReference:
-    return "StencilReference";
-  case DynamicState::eViewportWScalingNV:
-    return "ViewportWScalingNV";
-  case DynamicState::eDiscardRectangleEXT:
-    return "DiscardRectangleEXT";
-  case DynamicState::eSampleLocationsEXT:
-    return "SampleLocationsEXT";
-  case DynamicState::eRayTracingPipelineStackSizeKHR:
-    return "RayTracingPipelineStackSizeKHR";
-  case DynamicState::eViewportShadingRatePaletteNV:
-    return "ViewportShadingRatePaletteNV";
-  case DynamicState::eViewportCoarseSampleOrderNV:
-    return "ViewportCoarseSampleOrderNV";
-  case DynamicState::eExclusiveScissorNV:
-    return "ExclusiveScissorNV";
-  case DynamicState::eFragmentShadingRateKHR:
-    return "FragmentShadingRateKHR";
-  case DynamicState::eLineStippleEXT:
-    return "LineStippleEXT";
-  case DynamicState::eCullModeEXT:
-    return "CullModeEXT";
-  case DynamicState::eFrontFaceEXT:
-    return "FrontFaceEXT";
-  case DynamicState::ePrimitiveTopologyEXT:
-    return "PrimitiveTopologyEXT";
-  case DynamicState::eViewportWithCountEXT:
-    return "ViewportWithCountEXT";
-  case DynamicState::eScissorWithCountEXT:
-    return "ScissorWithCountEXT";
-  case DynamicState::eVertexInputBindingStrideEXT:
-    return "VertexInputBindingStrideEXT";
-  case DynamicState::eDepthTestEnableEXT:
-    return "DepthTestEnableEXT";
-  case DynamicState::eDepthWriteEnableEXT:
-    return "DepthWriteEnableEXT";
-  case DynamicState::eDepthCompareOpEXT:
-    return "DepthCompareOpEXT";
-  case DynamicState::eDepthBoundsTestEnableEXT:
-    return "DepthBoundsTestEnableEXT";
-  case DynamicState::eStencilTestEnableEXT:
-    return "StencilTestEnableEXT";
-  case DynamicState::eStencilOpEXT:
-    return "StencilOpEXT";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class EventCreateFlagBits : VkEventCreateFlags {
-  eDeviceOnlyKHR = VK_EVENT_CREATE_DEVICE_ONLY_BIT_KHR
-};
-
-VULKAN_HPP_INLINE std::string to_string(EventCreateFlagBits value) {
-  switch (value) {
-  case EventCreateFlagBits::eDeviceOnlyKHR:
-    return "DeviceOnlyKHR";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class ExternalFenceFeatureFlagBits : VkExternalFenceFeatureFlags {
-  eExportable = VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT,
-  eImportable = VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT
-};
-using ExternalFenceFeatureFlagBitsKHR = ExternalFenceFeatureFlagBits;
-
-VULKAN_HPP_INLINE std::string to_string(ExternalFenceFeatureFlagBits value) {
-  switch (value) {
-  case ExternalFenceFeatureFlagBits::eExportable:
-    return "Exportable";
-  case ExternalFenceFeatureFlagBits::eImportable:
-    return "Importable";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class ExternalFenceHandleTypeFlagBits : VkExternalFenceHandleTypeFlags {
-  eOpaqueFd = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT,
-  eOpaqueWin32 = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT,
-  eOpaqueWin32Kmt = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
-  eSyncFd = VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT
-};
-using ExternalFenceHandleTypeFlagBitsKHR = ExternalFenceHandleTypeFlagBits;
-
-VULKAN_HPP_INLINE std::string to_string(ExternalFenceHandleTypeFlagBits value) {
-  switch (value) {
-  case ExternalFenceHandleTypeFlagBits::eOpaqueFd:
-    return "OpaqueFd";
-  case ExternalFenceHandleTypeFlagBits::eOpaqueWin32:
-    return "OpaqueWin32";
-  case ExternalFenceHandleTypeFlagBits::eOpaqueWin32Kmt:
-    return "OpaqueWin32Kmt";
-  case ExternalFenceHandleTypeFlagBits::eSyncFd:
-    return "SyncFd";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class ExternalMemoryFeatureFlagBits : VkExternalMemoryFeatureFlags {
-  eDedicatedOnly = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT,
-  eExportable = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT,
-  eImportable = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT
-};
-using ExternalMemoryFeatureFlagBitsKHR = ExternalMemoryFeatureFlagBits;
-
-VULKAN_HPP_INLINE std::string to_string(ExternalMemoryFeatureFlagBits value) {
-  switch (value) {
-  case ExternalMemoryFeatureFlagBits::eDedicatedOnly:
-    return "DedicatedOnly";
-  case ExternalMemoryFeatureFlagBits::eExportable:
-    return "Exportable";
-  case ExternalMemoryFeatureFlagBits::eImportable:
-    return "Importable";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class ExternalMemoryFeatureFlagBitsNV : VkExternalMemoryFeatureFlagsNV {
-  eDedicatedOnly = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV,
-  eExportable = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV,
-  eImportable = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV
-};
-
-VULKAN_HPP_INLINE std::string to_string(ExternalMemoryFeatureFlagBitsNV value) {
-  switch (value) {
-  case ExternalMemoryFeatureFlagBitsNV::eDedicatedOnly:
-    return "DedicatedOnly";
-  case ExternalMemoryFeatureFlagBitsNV::eExportable:
-    return "Exportable";
-  case ExternalMemoryFeatureFlagBitsNV::eImportable:
-    return "Importable";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class ExternalMemoryHandleTypeFlagBits : VkExternalMemoryHandleTypeFlags {
-  // clang-format off
-      eOpaqueFd = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT
-    , eOpaqueWin32 = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT
-    , eOpaqueWin32Kmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT
-    , eD3D11Texture = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT
-    , eD3D11TextureKmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT
-    , eD3D12Heap = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT
-    , eD3D12Resource = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT
-    , eDmaBufEXT = VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT
-#if defined( VK_USE_PLATFORM_ANDROID_KHR )
-    , eAndroidHardwareBufferANDROID = VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID
-#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
-    , eHostAllocationEXT = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT
-    , eHostMappedForeignMemoryEXT = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT
-#if defined( VK_USE_PLATFORM_FUCHSIA )
-    , eZirconVmoFUCHSIA = VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA
-#endif /*VK_USE_PLATFORM_FUCHSIA*/
-  // clang-format on
-};
-using ExternalMemoryHandleTypeFlagBitsKHR = ExternalMemoryHandleTypeFlagBits;
-
-VULKAN_HPP_INLINE std::string
-to_string(ExternalMemoryHandleTypeFlagBits value) {
-  switch (value) {
-  case ExternalMemoryHandleTypeFlagBits::eOpaqueFd:
-    return "OpaqueFd";
-  case ExternalMemoryHandleTypeFlagBits::eOpaqueWin32:
-    return "OpaqueWin32";
-  case ExternalMemoryHandleTypeFlagBits::eOpaqueWin32Kmt:
-    return "OpaqueWin32Kmt";
-  case ExternalMemoryHandleTypeFlagBits::eD3D11Texture:
-    return "D3D11Texture";
-  case ExternalMemoryHandleTypeFlagBits::eD3D11TextureKmt:
-    return "D3D11TextureKmt";
-  case ExternalMemoryHandleTypeFlagBits::eD3D12Heap:
-    return "D3D12Heap";
-  case ExternalMemoryHandleTypeFlagBits::eD3D12Resource:
-    return "D3D12Resource";
-  case ExternalMemoryHandleTypeFlagBits::eDmaBufEXT:
-    return "DmaBufEXT";
-#if defined(VK_USE_PLATFORM_ANDROID_KHR)
-  case ExternalMemoryHandleTypeFlagBits::eAndroidHardwareBufferANDROID:
-    return "AndroidHardwareBufferANDROID";
-#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
-  case ExternalMemoryHandleTypeFlagBits::eHostAllocationEXT:
-    return "HostAllocationEXT";
-  case ExternalMemoryHandleTypeFlagBits::eHostMappedForeignMemoryEXT:
-    return "HostMappedForeignMemoryEXT";
-#if defined(VK_USE_PLATFORM_FUCHSIA)
-  case ExternalMemoryHandleTypeFlagBits::eZirconVmoFUCHSIA:
-    return "ZirconVmoFUCHSIA";
-#endif /*VK_USE_PLATFORM_FUCHSIA*/
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class
-    ExternalMemoryHandleTypeFlagBitsNV : VkExternalMemoryHandleTypeFlagsNV {
-      eOpaqueWin32 = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV,
-      eOpaqueWin32Kmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV,
-      eD3D11Image = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV,
-      eD3D11ImageKmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV
-    };
-
-VULKAN_HPP_INLINE std::string
-to_string(ExternalMemoryHandleTypeFlagBitsNV value) {
-  switch (value) {
-  case ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32:
-    return "OpaqueWin32";
-  case ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32Kmt:
-    return "OpaqueWin32Kmt";
-  case ExternalMemoryHandleTypeFlagBitsNV::eD3D11Image:
-    return "D3D11Image";
-  case ExternalMemoryHandleTypeFlagBitsNV::eD3D11ImageKmt:
-    return "D3D11ImageKmt";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class ExternalSemaphoreFeatureFlagBits : VkExternalSemaphoreFeatureFlags {
-  eExportable = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT,
-  eImportable = VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT
-};
-using ExternalSemaphoreFeatureFlagBitsKHR = ExternalSemaphoreFeatureFlagBits;
-
-VULKAN_HPP_INLINE std::string
-to_string(ExternalSemaphoreFeatureFlagBits value) {
-  switch (value) {
-  case ExternalSemaphoreFeatureFlagBits::eExportable:
-    return "Exportable";
-  case ExternalSemaphoreFeatureFlagBits::eImportable:
-    return "Importable";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class
-    ExternalSemaphoreHandleTypeFlagBits : VkExternalSemaphoreHandleTypeFlags {
-      // clang-format off
-      eOpaqueFd = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT
-    , eOpaqueWin32 = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT
-    , eOpaqueWin32Kmt = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT
-    , eD3D12Fence = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT
-    , eSyncFd = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT
-#if defined( VK_USE_PLATFORM_FUCHSIA )
-    , eZirconEventFUCHSIA = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA
-#endif /*VK_USE_PLATFORM_FUCHSIA*/
-    , eD3D11Fence = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE_BIT
-      // clang-format on
-    };
-using ExternalSemaphoreHandleTypeFlagBitsKHR =
-    ExternalSemaphoreHandleTypeFlagBits;
-
-VULKAN_HPP_INLINE std::string
-to_string(ExternalSemaphoreHandleTypeFlagBits value) {
-  switch (value) {
-  case ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd:
-    return "OpaqueFd";
-  case ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32:
-    return "OpaqueWin32";
-  case ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32Kmt:
-    return "OpaqueWin32Kmt";
-  case ExternalSemaphoreHandleTypeFlagBits::eD3D12Fence:
-    return "D3D12Fence";
-  case ExternalSemaphoreHandleTypeFlagBits::eSyncFd:
-    return "SyncFd";
-#if defined(VK_USE_PLATFORM_FUCHSIA)
-  case ExternalSemaphoreHandleTypeFlagBits::eZirconEventFUCHSIA:
-    return "ZirconEventFUCHSIA";
-#endif /*VK_USE_PLATFORM_FUCHSIA*/
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class FenceCreateFlagBits : VkFenceCreateFlags {
-  eSignaled = VK_FENCE_CREATE_SIGNALED_BIT
-};
-
-VULKAN_HPP_INLINE std::string to_string(FenceCreateFlagBits value) {
-  switch (value) {
-  case FenceCreateFlagBits::eSignaled:
-    return "Signaled";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class FenceImportFlagBits : VkFenceImportFlags {
-  eTemporary = VK_FENCE_IMPORT_TEMPORARY_BIT
-};
-using FenceImportFlagBitsKHR = FenceImportFlagBits;
-
-VULKAN_HPP_INLINE std::string to_string(FenceImportFlagBits value) {
-  switch (value) {
-  case FenceImportFlagBits::eTemporary:
-    return "Temporary";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class Filter {
-  eNearest = VK_FILTER_NEAREST,
-  eLinear = VK_FILTER_LINEAR,
-  eCubicIMG = VK_FILTER_CUBIC_IMG,
-  eCubicEXT = VK_FILTER_CUBIC_EXT
-};
-
-VULKAN_HPP_INLINE std::string to_string(Filter value) {
-  switch (value) {
-  case Filter::eNearest:
-    return "Nearest";
-  case Filter::eLinear:
-    return "Linear";
-  case Filter::eCubicIMG:
-    return "CubicIMG";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class Format {
-  eUndefined = VK_FORMAT_UNDEFINED,
-  eR4G4UnormPack8 = VK_FORMAT_R4G4_UNORM_PACK8,
-  eR4G4B4A4UnormPack16 = VK_FORMAT_R4G4B4A4_UNORM_PACK16,
-  eB4G4R4A4UnormPack16 = VK_FORMAT_B4G4R4A4_UNORM_PACK16,
-  eR5G6B5UnormPack16 = VK_FORMAT_R5G6B5_UNORM_PACK16,
-  eB5G6R5UnormPack16 = VK_FORMAT_B5G6R5_UNORM_PACK16,
-  eR5G5B5A1UnormPack16 = VK_FORMAT_R5G5B5A1_UNORM_PACK16,
-  eB5G5R5A1UnormPack16 = VK_FORMAT_B5G5R5A1_UNORM_PACK16,
-  eA1R5G5B5UnormPack16 = VK_FORMAT_A1R5G5B5_UNORM_PACK16,
-  eR8Unorm = VK_FORMAT_R8_UNORM,
-  eR8Snorm = VK_FORMAT_R8_SNORM,
-  eR8Uscaled = VK_FORMAT_R8_USCALED,
-  eR8Sscaled = VK_FORMAT_R8_SSCALED,
-  eR8Uint = VK_FORMAT_R8_UINT,
-  eR8Sint = VK_FORMAT_R8_SINT,
-  eR8Srgb = VK_FORMAT_R8_SRGB,
-  eR8G8Unorm = VK_FORMAT_R8G8_UNORM,
-  eR8G8Snorm = VK_FORMAT_R8G8_SNORM,
-  eR8G8Uscaled = VK_FORMAT_R8G8_USCALED,
-  eR8G8Sscaled = VK_FORMAT_R8G8_SSCALED,
-  eR8G8Uint = VK_FORMAT_R8G8_UINT,
-  eR8G8Sint = VK_FORMAT_R8G8_SINT,
-  eR8G8Srgb = VK_FORMAT_R8G8_SRGB,
-  eR8G8B8Unorm = VK_FORMAT_R8G8B8_UNORM,
-  eR8G8B8Snorm = VK_FORMAT_R8G8B8_SNORM,
-  eR8G8B8Uscaled = VK_FORMAT_R8G8B8_USCALED,
-  eR8G8B8Sscaled = VK_FORMAT_R8G8B8_SSCALED,
-  eR8G8B8Uint = VK_FORMAT_R8G8B8_UINT,
-  eR8G8B8Sint = VK_FORMAT_R8G8B8_SINT,
-  eR8G8B8Srgb = VK_FORMAT_R8G8B8_SRGB,
-  eB8G8R8Unorm = VK_FORMAT_B8G8R8_UNORM,
-  eB8G8R8Snorm = VK_FORMAT_B8G8R8_SNORM,
-  eB8G8R8Uscaled = VK_FORMAT_B8G8R8_USCALED,
-  eB8G8R8Sscaled = VK_FORMAT_B8G8R8_SSCALED,
-  eB8G8R8Uint = VK_FORMAT_B8G8R8_UINT,
-  eB8G8R8Sint = VK_FORMAT_B8G8R8_SINT,
-  eB8G8R8Srgb = VK_FORMAT_B8G8R8_SRGB,
-  eR8G8B8A8Unorm = VK_FORMAT_R8G8B8A8_UNORM,
-  eR8G8B8A8Snorm = VK_FORMAT_R8G8B8A8_SNORM,
-  eR8G8B8A8Uscaled = VK_FORMAT_R8G8B8A8_USCALED,
-  eR8G8B8A8Sscaled = VK_FORMAT_R8G8B8A8_SSCALED,
-  eR8G8B8A8Uint = VK_FORMAT_R8G8B8A8_UINT,
-  eR8G8B8A8Sint = VK_FORMAT_R8G8B8A8_SINT,
-  eR8G8B8A8Srgb = VK_FORMAT_R8G8B8A8_SRGB,
-  eB8G8R8A8Unorm = VK_FORMAT_B8G8R8A8_UNORM,
-  eB8G8R8A8Snorm = VK_FORMAT_B8G8R8A8_SNORM,
-  eB8G8R8A8Uscaled = VK_FORMAT_B8G8R8A8_USCALED,
-  eB8G8R8A8Sscaled = VK_FORMAT_B8G8R8A8_SSCALED,
-  eB8G8R8A8Uint = VK_FORMAT_B8G8R8A8_UINT,
-  eB8G8R8A8Sint = VK_FORMAT_B8G8R8A8_SINT,
-  eB8G8R8A8Srgb = VK_FORMAT_B8G8R8A8_SRGB,
-  eA8B8G8R8UnormPack32 = VK_FORMAT_A8B8G8R8_UNORM_PACK32,
-  eA8B8G8R8SnormPack32 = VK_FORMAT_A8B8G8R8_SNORM_PACK32,
-  eA8B8G8R8UscaledPack32 = VK_FORMAT_A8B8G8R8_USCALED_PACK32,
-  eA8B8G8R8SscaledPack32 = VK_FORMAT_A8B8G8R8_SSCALED_PACK32,
-  eA8B8G8R8UintPack32 = VK_FORMAT_A8B8G8R8_UINT_PACK32,
-  eA8B8G8R8SintPack32 = VK_FORMAT_A8B8G8R8_SINT_PACK32,
-  eA8B8G8R8SrgbPack32 = VK_FORMAT_A8B8G8R8_SRGB_PACK32,
-  eA2R10G10B10UnormPack32 = VK_FORMAT_A2R10G10B10_UNORM_PACK32,
-  eA2R10G10B10SnormPack32 = VK_FORMAT_A2R10G10B10_SNORM_PACK32,
-  eA2R10G10B10UscaledPack32 = VK_FORMAT_A2R10G10B10_USCALED_PACK32,
-  eA2R10G10B10SscaledPack32 = VK_FORMAT_A2R10G10B10_SSCALED_PACK32,
-  eA2R10G10B10UintPack32 = VK_FORMAT_A2R10G10B10_UINT_PACK32,
-  eA2R10G10B10SintPack32 = VK_FORMAT_A2R10G10B10_SINT_PACK32,
-  eA2B10G10R10UnormPack32 = VK_FORMAT_A2B10G10R10_UNORM_PACK32,
-  eA2B10G10R10SnormPack32 = VK_FORMAT_A2B10G10R10_SNORM_PACK32,
-  eA2B10G10R10UscaledPack32 = VK_FORMAT_A2B10G10R10_USCALED_PACK32,
-  eA2B10G10R10SscaledPack32 = VK_FORMAT_A2B10G10R10_SSCALED_PACK32,
-  eA2B10G10R10UintPack32 = VK_FORMAT_A2B10G10R10_UINT_PACK32,
-  eA2B10G10R10SintPack32 = VK_FORMAT_A2B10G10R10_SINT_PACK32,
-  eR16Unorm = VK_FORMAT_R16_UNORM,
-  eR16Snorm = VK_FORMAT_R16_SNORM,
-  eR16Uscaled = VK_FORMAT_R16_USCALED,
-  eR16Sscaled = VK_FORMAT_R16_SSCALED,
-  eR16Uint = VK_FORMAT_R16_UINT,
-  eR16Sint = VK_FORMAT_R16_SINT,
-  eR16Sfloat = VK_FORMAT_R16_SFLOAT,
-  eR16G16Unorm = VK_FORMAT_R16G16_UNORM,
-  eR16G16Snorm = VK_FORMAT_R16G16_SNORM,
-  eR16G16Uscaled = VK_FORMAT_R16G16_USCALED,
-  eR16G16Sscaled = VK_FORMAT_R16G16_SSCALED,
-  eR16G16Uint = VK_FORMAT_R16G16_UINT,
-  eR16G16Sint = VK_FORMAT_R16G16_SINT,
-  eR16G16Sfloat = VK_FORMAT_R16G16_SFLOAT,
-  eR16G16B16Unorm = VK_FORMAT_R16G16B16_UNORM,
-  eR16G16B16Snorm = VK_FORMAT_R16G16B16_SNORM,
-  eR16G16B16Uscaled = VK_FORMAT_R16G16B16_USCALED,
-  eR16G16B16Sscaled = VK_FORMAT_R16G16B16_SSCALED,
-  eR16G16B16Uint = VK_FORMAT_R16G16B16_UINT,
-  eR16G16B16Sint = VK_FORMAT_R16G16B16_SINT,
-  eR16G16B16Sfloat = VK_FORMAT_R16G16B16_SFLOAT,
-  eR16G16B16A16Unorm = VK_FORMAT_R16G16B16A16_UNORM,
-  eR16G16B16A16Snorm = VK_FORMAT_R16G16B16A16_SNORM,
-  eR16G16B16A16Uscaled = VK_FORMAT_R16G16B16A16_USCALED,
-  eR16G16B16A16Sscaled = VK_FORMAT_R16G16B16A16_SSCALED,
-  eR16G16B16A16Uint = VK_FORMAT_R16G16B16A16_UINT,
-  eR16G16B16A16Sint = VK_FORMAT_R16G16B16A16_SINT,
-  eR16G16B16A16Sfloat = VK_FORMAT_R16G16B16A16_SFLOAT,
-  eR32Uint = VK_FORMAT_R32_UINT,
-  eR32Sint = VK_FORMAT_R32_SINT,
-  eR32Sfloat = VK_FORMAT_R32_SFLOAT,
-  eR32G32Uint = VK_FORMAT_R32G32_UINT,
-  eR32G32Sint = VK_FORMAT_R32G32_SINT,
-  eR32G32Sfloat = VK_FORMAT_R32G32_SFLOAT,
-  eR32G32B32Uint = VK_FORMAT_R32G32B32_UINT,
-  eR32G32B32Sint = VK_FORMAT_R32G32B32_SINT,
-  eR32G32B32Sfloat = VK_FORMAT_R32G32B32_SFLOAT,
-  eR32G32B32A32Uint = VK_FORMAT_R32G32B32A32_UINT,
-  eR32G32B32A32Sint = VK_FORMAT_R32G32B32A32_SINT,
-  eR32G32B32A32Sfloat = VK_FORMAT_R32G32B32A32_SFLOAT,
-  eR64Uint = VK_FORMAT_R64_UINT,
-  eR64Sint = VK_FORMAT_R64_SINT,
-  eR64Sfloat = VK_FORMAT_R64_SFLOAT,
-  eR64G64Uint = VK_FORMAT_R64G64_UINT,
-  eR64G64Sint = VK_FORMAT_R64G64_SINT,
-  eR64G64Sfloat = VK_FORMAT_R64G64_SFLOAT,
-  eR64G64B64Uint = VK_FORMAT_R64G64B64_UINT,
-  eR64G64B64Sint = VK_FORMAT_R64G64B64_SINT,
-  eR64G64B64Sfloat = VK_FORMAT_R64G64B64_SFLOAT,
-  eR64G64B64A64Uint = VK_FORMAT_R64G64B64A64_UINT,
-  eR64G64B64A64Sint = VK_FORMAT_R64G64B64A64_SINT,
-  eR64G64B64A64Sfloat = VK_FORMAT_R64G64B64A64_SFLOAT,
-  eB10G11R11UfloatPack32 = VK_FORMAT_B10G11R11_UFLOAT_PACK32,
-  eE5B9G9R9UfloatPack32 = VK_FORMAT_E5B9G9R9_UFLOAT_PACK32,
-  eD16Unorm = VK_FORMAT_D16_UNORM,
-  eX8D24UnormPack32 = VK_FORMAT_X8_D24_UNORM_PACK32,
-  eD32Sfloat = VK_FORMAT_D32_SFLOAT,
-  eS8Uint = VK_FORMAT_S8_UINT,
-  eD16UnormS8Uint = VK_FORMAT_D16_UNORM_S8_UINT,
-  eD24UnormS8Uint = VK_FORMAT_D24_UNORM_S8_UINT,
-  eD32SfloatS8Uint = VK_FORMAT_D32_SFLOAT_S8_UINT,
-  eBc1RgbUnormBlock = VK_FORMAT_BC1_RGB_UNORM_BLOCK,
-  eBc1RgbSrgbBlock = VK_FORMAT_BC1_RGB_SRGB_BLOCK,
-  eBc1RgbaUnormBlock = VK_FORMAT_BC1_RGBA_UNORM_BLOCK,
-  eBc1RgbaSrgbBlock = VK_FORMAT_BC1_RGBA_SRGB_BLOCK,
-  eBc2UnormBlock = VK_FORMAT_BC2_UNORM_BLOCK,
-  eBc2SrgbBlock = VK_FORMAT_BC2_SRGB_BLOCK,
-  eBc3UnormBlock = VK_FORMAT_BC3_UNORM_BLOCK,
-  eBc3SrgbBlock = VK_FORMAT_BC3_SRGB_BLOCK,
-  eBc4UnormBlock = VK_FORMAT_BC4_UNORM_BLOCK,
-  eBc4SnormBlock = VK_FORMAT_BC4_SNORM_BLOCK,
-  eBc5UnormBlock = VK_FORMAT_BC5_UNORM_BLOCK,
-  eBc5SnormBlock = VK_FORMAT_BC5_SNORM_BLOCK,
-  eBc6HUfloatBlock = VK_FORMAT_BC6H_UFLOAT_BLOCK,
-  eBc6HSfloatBlock = VK_FORMAT_BC6H_SFLOAT_BLOCK,
-  eBc7UnormBlock = VK_FORMAT_BC7_UNORM_BLOCK,
-  eBc7SrgbBlock = VK_FORMAT_BC7_SRGB_BLOCK,
-  eEtc2R8G8B8UnormBlock = VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK,
-  eEtc2R8G8B8SrgbBlock = VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK,
-  eEtc2R8G8B8A1UnormBlock = VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK,
-  eEtc2R8G8B8A1SrgbBlock = VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK,
-  eEtc2R8G8B8A8UnormBlock = VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK,
-  eEtc2R8G8B8A8SrgbBlock = VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK,
-  eEacR11UnormBlock = VK_FORMAT_EAC_R11_UNORM_BLOCK,
-  eEacR11SnormBlock = VK_FORMAT_EAC_R11_SNORM_BLOCK,
-  eEacR11G11UnormBlock = VK_FORMAT_EAC_R11G11_UNORM_BLOCK,
-  eEacR11G11SnormBlock = VK_FORMAT_EAC_R11G11_SNORM_BLOCK,
-  eAstc4x4UnormBlock = VK_FORMAT_ASTC_4x4_UNORM_BLOCK,
-  eAstc4x4SrgbBlock = VK_FORMAT_ASTC_4x4_SRGB_BLOCK,
-  eAstc5x4UnormBlock = VK_FORMAT_ASTC_5x4_UNORM_BLOCK,
-  eAstc5x4SrgbBlock = VK_FORMAT_ASTC_5x4_SRGB_BLOCK,
-  eAstc5x5UnormBlock = VK_FORMAT_ASTC_5x5_UNORM_BLOCK,
-  eAstc5x5SrgbBlock = VK_FORMAT_ASTC_5x5_SRGB_BLOCK,
-  eAstc6x5UnormBlock = VK_FORMAT_ASTC_6x5_UNORM_BLOCK,
-  eAstc6x5SrgbBlock = VK_FORMAT_ASTC_6x5_SRGB_BLOCK,
-  eAstc6x6UnormBlock = VK_FORMAT_ASTC_6x6_UNORM_BLOCK,
-  eAstc6x6SrgbBlock = VK_FORMAT_ASTC_6x6_SRGB_BLOCK,
-  eAstc8x5UnormBlock = VK_FORMAT_ASTC_8x5_UNORM_BLOCK,
-  eAstc8x5SrgbBlock = VK_FORMAT_ASTC_8x5_SRGB_BLOCK,
-  eAstc8x6UnormBlock = VK_FORMAT_ASTC_8x6_UNORM_BLOCK,
-  eAstc8x6SrgbBlock = VK_FORMAT_ASTC_8x6_SRGB_BLOCK,
-  eAstc8x8UnormBlock = VK_FORMAT_ASTC_8x8_UNORM_BLOCK,
-  eAstc8x8SrgbBlock = VK_FORMAT_ASTC_8x8_SRGB_BLOCK,
-  eAstc10x5UnormBlock = VK_FORMAT_ASTC_10x5_UNORM_BLOCK,
-  eAstc10x5SrgbBlock = VK_FORMAT_ASTC_10x5_SRGB_BLOCK,
-  eAstc10x6UnormBlock = VK_FORMAT_ASTC_10x6_UNORM_BLOCK,
-  eAstc10x6SrgbBlock = VK_FORMAT_ASTC_10x6_SRGB_BLOCK,
-  eAstc10x8UnormBlock = VK_FORMAT_ASTC_10x8_UNORM_BLOCK,
-  eAstc10x8SrgbBlock = VK_FORMAT_ASTC_10x8_SRGB_BLOCK,
-  eAstc10x10UnormBlock = VK_FORMAT_ASTC_10x10_UNORM_BLOCK,
-  eAstc10x10SrgbBlock = VK_FORMAT_ASTC_10x10_SRGB_BLOCK,
-  eAstc12x10UnormBlock = VK_FORMAT_ASTC_12x10_UNORM_BLOCK,
-  eAstc12x10SrgbBlock = VK_FORMAT_ASTC_12x10_SRGB_BLOCK,
-  eAstc12x12UnormBlock = VK_FORMAT_ASTC_12x12_UNORM_BLOCK,
-  eAstc12x12SrgbBlock = VK_FORMAT_ASTC_12x12_SRGB_BLOCK,
-  eG8B8G8R8422Unorm = VK_FORMAT_G8B8G8R8_422_UNORM,
-  eB8G8R8G8422Unorm = VK_FORMAT_B8G8R8G8_422_UNORM,
-  eG8B8R83Plane420Unorm = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM,
-  eG8B8R82Plane420Unorm = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM,
-  eG8B8R83Plane422Unorm = VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM,
-  eG8B8R82Plane422Unorm = VK_FORMAT_G8_B8R8_2PLANE_422_UNORM,
-  eG8B8R83Plane444Unorm = VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM,
-  eR10X6UnormPack16 = VK_FORMAT_R10X6_UNORM_PACK16,
-  eR10X6G10X6Unorm2Pack16 = VK_FORMAT_R10X6G10X6_UNORM_2PACK16,
-  eR10X6G10X6B10X6A10X6Unorm4Pack16 =
-      VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16,
-  eG10X6B10X6G10X6R10X6422Unorm4Pack16 =
-      VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16,
-  eB10X6G10X6R10X6G10X6422Unorm4Pack16 =
-      VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16,
-  eG10X6B10X6R10X63Plane420Unorm3Pack16 =
-      VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16,
-  eG10X6B10X6R10X62Plane420Unorm3Pack16 =
-      VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16,
-  eG10X6B10X6R10X63Plane422Unorm3Pack16 =
-      VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16,
-  eG10X6B10X6R10X62Plane422Unorm3Pack16 =
-      VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16,
-  eG10X6B10X6R10X63Plane444Unorm3Pack16 =
-      VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16,
-  eR12X4UnormPack16 = VK_FORMAT_R12X4_UNORM_PACK16,
-  eR12X4G12X4Unorm2Pack16 = VK_FORMAT_R12X4G12X4_UNORM_2PACK16,
-  eR12X4G12X4B12X4A12X4Unorm4Pack16 =
-      VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16,
-  eG12X4B12X4G12X4R12X4422Unorm4Pack16 =
-      VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16,
-  eB12X4G12X4R12X4G12X4422Unorm4Pack16 =
-      VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16,
-  eG12X4B12X4R12X43Plane420Unorm3Pack16 =
-      VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16,
-  eG12X4B12X4R12X42Plane420Unorm3Pack16 =
-      VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16,
-  eG12X4B12X4R12X43Plane422Unorm3Pack16 =
-      VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16,
-  eG12X4B12X4R12X42Plane422Unorm3Pack16 =
-      VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16,
-  eG12X4B12X4R12X43Plane444Unorm3Pack16 =
-      VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16,
-  eG16B16G16R16422Unorm = VK_FORMAT_G16B16G16R16_422_UNORM,
-  eB16G16R16G16422Unorm = VK_FORMAT_B16G16R16G16_422_UNORM,
-  eG16B16R163Plane420Unorm = VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM,
-  eG16B16R162Plane420Unorm = VK_FORMAT_G16_B16R16_2PLANE_420_UNORM,
-  eG16B16R163Plane422Unorm = VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM,
-  eG16B16R162Plane422Unorm = VK_FORMAT_G16_B16R16_2PLANE_422_UNORM,
-  eG16B16R163Plane444Unorm = VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM,
-  ePvrtc12BppUnormBlockIMG = VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG,
-  ePvrtc14BppUnormBlockIMG = VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG,
-  ePvrtc22BppUnormBlockIMG = VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG,
-  ePvrtc24BppUnormBlockIMG = VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG,
-  ePvrtc12BppSrgbBlockIMG = VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG,
-  ePvrtc14BppSrgbBlockIMG = VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG,
-  ePvrtc22BppSrgbBlockIMG = VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG,
-  ePvrtc24BppSrgbBlockIMG = VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG,
-  eAstc4x4SfloatBlockEXT = VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT,
-  eAstc5x4SfloatBlockEXT = VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT,
-  eAstc5x5SfloatBlockEXT = VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT,
-  eAstc6x5SfloatBlockEXT = VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT,
-  eAstc6x6SfloatBlockEXT = VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT,
-  eAstc8x5SfloatBlockEXT = VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT,
-  eAstc8x6SfloatBlockEXT = VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT,
-  eAstc8x8SfloatBlockEXT = VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT,
-  eAstc10x5SfloatBlockEXT = VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT,
-  eAstc10x6SfloatBlockEXT = VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT,
-  eAstc10x8SfloatBlockEXT = VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT,
-  eAstc10x10SfloatBlockEXT = VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT,
-  eAstc12x10SfloatBlockEXT = VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT,
-  eAstc12x12SfloatBlockEXT = VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT,
-  eA4R4G4B4UnormPack16EXT = VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT,
-  eA4B4G4R4UnormPack16EXT = VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT,
-  eB10X6G10X6R10X6G10X6422Unorm4Pack16KHR =
-      VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR,
-  eB12X4G12X4R12X4G12X4422Unorm4Pack16KHR =
-      VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR,
-  eB16G16R16G16422UnormKHR = VK_FORMAT_B16G16R16G16_422_UNORM_KHR,
-  eB8G8R8G8422UnormKHR = VK_FORMAT_B8G8R8G8_422_UNORM_KHR,
-  eG10X6B10X6G10X6R10X6422Unorm4Pack16KHR =
-      VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR,
-  eG10X6B10X6R10X62Plane420Unorm3Pack16KHR =
-      VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR,
-  eG10X6B10X6R10X62Plane422Unorm3Pack16KHR =
-      VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR,
-  eG10X6B10X6R10X63Plane420Unorm3Pack16KHR =
-      VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR,
-  eG10X6B10X6R10X63Plane422Unorm3Pack16KHR =
-      VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR,
-  eG10X6B10X6R10X63Plane444Unorm3Pack16KHR =
-      VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR,
-  eG12X4B12X4G12X4R12X4422Unorm4Pack16KHR =
-      VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR,
-  eG12X4B12X4R12X42Plane420Unorm3Pack16KHR =
-      VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR,
-  eG12X4B12X4R12X42Plane422Unorm3Pack16KHR =
-      VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR,
-  eG12X4B12X4R12X43Plane420Unorm3Pack16KHR =
-      VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR,
-  eG12X4B12X4R12X43Plane422Unorm3Pack16KHR =
-      VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR,
-  eG12X4B12X4R12X43Plane444Unorm3Pack16KHR =
-      VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR,
-  eG16B16G16R16422UnormKHR = VK_FORMAT_G16B16G16R16_422_UNORM_KHR,
-  eG16B16R162Plane420UnormKHR = VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR,
-  eG16B16R162Plane422UnormKHR = VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR,
-  eG16B16R163Plane420UnormKHR = VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR,
-  eG16B16R163Plane422UnormKHR = VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR,
-  eG16B16R163Plane444UnormKHR = VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR,
-  eG8B8G8R8422UnormKHR = VK_FORMAT_G8B8G8R8_422_UNORM_KHR,
-  eG8B8R82Plane420UnormKHR = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR,
-  eG8B8R82Plane422UnormKHR = VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR,
-  eG8B8R83Plane420UnormKHR = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR,
-  eG8B8R83Plane422UnormKHR = VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR,
-  eG8B8R83Plane444UnormKHR = VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR,
-  eR10X6G10X6B10X6A10X6Unorm4Pack16KHR =
-      VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR,
-  eR10X6G10X6Unorm2Pack16KHR = VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR,
-  eR10X6UnormPack16KHR = VK_FORMAT_R10X6_UNORM_PACK16_KHR,
-  eR12X4G12X4B12X4A12X4Unorm4Pack16KHR =
-      VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR,
-  eR12X4G12X4Unorm2Pack16KHR = VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR,
-  eR12X4UnormPack16KHR = VK_FORMAT_R12X4_UNORM_PACK16_KHR
-};
-
-VULKAN_HPP_INLINE std::string to_string(Format value) {
-  switch (value) {
-  case Format::eUndefined:
-    return "Undefined";
-  case Format::eR4G4UnormPack8:
-    return "R4G4UnormPack8";
-  case Format::eR4G4B4A4UnormPack16:
-    return "R4G4B4A4UnormPack16";
-  case Format::eB4G4R4A4UnormPack16:
-    return "B4G4R4A4UnormPack16";
-  case Format::eR5G6B5UnormPack16:
-    return "R5G6B5UnormPack16";
-  case Format::eB5G6R5UnormPack16:
-    return "B5G6R5UnormPack16";
-  case Format::eR5G5B5A1UnormPack16:
-    return "R5G5B5A1UnormPack16";
-  case Format::eB5G5R5A1UnormPack16:
-    return "B5G5R5A1UnormPack16";
-  case Format::eA1R5G5B5UnormPack16:
-    return "A1R5G5B5UnormPack16";
-  case Format::eR8Unorm:
-    return "R8Unorm";
-  case Format::eR8Snorm:
-    return "R8Snorm";
-  case Format::eR8Uscaled:
-    return "R8Uscaled";
-  case Format::eR8Sscaled:
-    return "R8Sscaled";
-  case Format::eR8Uint:
-    return "R8Uint";
-  case Format::eR8Sint:
-    return "R8Sint";
-  case Format::eR8Srgb:
-    return "R8Srgb";
-  case Format::eR8G8Unorm:
-    return "R8G8Unorm";
-  case Format::eR8G8Snorm:
-    return "R8G8Snorm";
-  case Format::eR8G8Uscaled:
-    return "R8G8Uscaled";
-  case Format::eR8G8Sscaled:
-    return "R8G8Sscaled";
-  case Format::eR8G8Uint:
-    return "R8G8Uint";
-  case Format::eR8G8Sint:
-    return "R8G8Sint";
-  case Format::eR8G8Srgb:
-    return "R8G8Srgb";
-  case Format::eR8G8B8Unorm:
-    return "R8G8B8Unorm";
-  case Format::eR8G8B8Snorm:
-    return "R8G8B8Snorm";
-  case Format::eR8G8B8Uscaled:
-    return "R8G8B8Uscaled";
-  case Format::eR8G8B8Sscaled:
-    return "R8G8B8Sscaled";
-  case Format::eR8G8B8Uint:
-    return "R8G8B8Uint";
-  case Format::eR8G8B8Sint:
-    return "R8G8B8Sint";
-  case Format::eR8G8B8Srgb:
-    return "R8G8B8Srgb";
-  case Format::eB8G8R8Unorm:
-    return "B8G8R8Unorm";
-  case Format::eB8G8R8Snorm:
-    return "B8G8R8Snorm";
-  case Format::eB8G8R8Uscaled:
-    return "B8G8R8Uscaled";
-  case Format::eB8G8R8Sscaled:
-    return "B8G8R8Sscaled";
-  case Format::eB8G8R8Uint:
-    return "B8G8R8Uint";
-  case Format::eB8G8R8Sint:
-    return "B8G8R8Sint";
-  case Format::eB8G8R8Srgb:
-    return "B8G8R8Srgb";
-  case Format::eR8G8B8A8Unorm:
-    return "R8G8B8A8Unorm";
-  case Format::eR8G8B8A8Snorm:
-    return "R8G8B8A8Snorm";
-  case Format::eR8G8B8A8Uscaled:
-    return "R8G8B8A8Uscaled";
-  case Format::eR8G8B8A8Sscaled:
-    return "R8G8B8A8Sscaled";
-  case Format::eR8G8B8A8Uint:
-    return "R8G8B8A8Uint";
-  case Format::eR8G8B8A8Sint:
-    return "R8G8B8A8Sint";
-  case Format::eR8G8B8A8Srgb:
-    return "R8G8B8A8Srgb";
-  case Format::eB8G8R8A8Unorm:
-    return "B8G8R8A8Unorm";
-  case Format::eB8G8R8A8Snorm:
-    return "B8G8R8A8Snorm";
-  case Format::eB8G8R8A8Uscaled:
-    return "B8G8R8A8Uscaled";
-  case Format::eB8G8R8A8Sscaled:
-    return "B8G8R8A8Sscaled";
-  case Format::eB8G8R8A8Uint:
-    return "B8G8R8A8Uint";
-  case Format::eB8G8R8A8Sint:
-    return "B8G8R8A8Sint";
-  case Format::eB8G8R8A8Srgb:
-    return "B8G8R8A8Srgb";
-  case Format::eA8B8G8R8UnormPack32:
-    return "A8B8G8R8UnormPack32";
-  case Format::eA8B8G8R8SnormPack32:
-    return "A8B8G8R8SnormPack32";
-  case Format::eA8B8G8R8UscaledPack32:
-    return "A8B8G8R8UscaledPack32";
-  case Format::eA8B8G8R8SscaledPack32:
-    return "A8B8G8R8SscaledPack32";
-  case Format::eA8B8G8R8UintPack32:
-    return "A8B8G8R8UintPack32";
-  case Format::eA8B8G8R8SintPack32:
-    return "A8B8G8R8SintPack32";
-  case Format::eA8B8G8R8SrgbPack32:
-    return "A8B8G8R8SrgbPack32";
-  case Format::eA2R10G10B10UnormPack32:
-    return "A2R10G10B10UnormPack32";
-  case Format::eA2R10G10B10SnormPack32:
-    return "A2R10G10B10SnormPack32";
-  case Format::eA2R10G10B10UscaledPack32:
-    return "A2R10G10B10UscaledPack32";
-  case Format::eA2R10G10B10SscaledPack32:
-    return "A2R10G10B10SscaledPack32";
-  case Format::eA2R10G10B10UintPack32:
-    return "A2R10G10B10UintPack32";
-  case Format::eA2R10G10B10SintPack32:
-    return "A2R10G10B10SintPack32";
-  case Format::eA2B10G10R10UnormPack32:
-    return "A2B10G10R10UnormPack32";
-  case Format::eA2B10G10R10SnormPack32:
-    return "A2B10G10R10SnormPack32";
-  case Format::eA2B10G10R10UscaledPack32:
-    return "A2B10G10R10UscaledPack32";
-  case Format::eA2B10G10R10SscaledPack32:
-    return "A2B10G10R10SscaledPack32";
-  case Format::eA2B10G10R10UintPack32:
-    return "A2B10G10R10UintPack32";
-  case Format::eA2B10G10R10SintPack32:
-    return "A2B10G10R10SintPack32";
-  case Format::eR16Unorm:
-    return "R16Unorm";
-  case Format::eR16Snorm:
-    return "R16Snorm";
-  case Format::eR16Uscaled:
-    return "R16Uscaled";
-  case Format::eR16Sscaled:
-    return "R16Sscaled";
-  case Format::eR16Uint:
-    return "R16Uint";
-  case Format::eR16Sint:
-    return "R16Sint";
-  case Format::eR16Sfloat:
-    return "R16Sfloat";
-  case Format::eR16G16Unorm:
-    return "R16G16Unorm";
-  case Format::eR16G16Snorm:
-    return "R16G16Snorm";
-  case Format::eR16G16Uscaled:
-    return "R16G16Uscaled";
-  case Format::eR16G16Sscaled:
-    return "R16G16Sscaled";
-  case Format::eR16G16Uint:
-    return "R16G16Uint";
-  case Format::eR16G16Sint:
-    return "R16G16Sint";
-  case Format::eR16G16Sfloat:
-    return "R16G16Sfloat";
-  case Format::eR16G16B16Unorm:
-    return "R16G16B16Unorm";
-  case Format::eR16G16B16Snorm:
-    return "R16G16B16Snorm";
-  case Format::eR16G16B16Uscaled:
-    return "R16G16B16Uscaled";
-  case Format::eR16G16B16Sscaled:
-    return "R16G16B16Sscaled";
-  case Format::eR16G16B16Uint:
-    return "R16G16B16Uint";
-  case Format::eR16G16B16Sint:
-    return "R16G16B16Sint";
-  case Format::eR16G16B16Sfloat:
-    return "R16G16B16Sfloat";
-  case Format::eR16G16B16A16Unorm:
-    return "R16G16B16A16Unorm";
-  case Format::eR16G16B16A16Snorm:
-    return "R16G16B16A16Snorm";
-  case Format::eR16G16B16A16Uscaled:
-    return "R16G16B16A16Uscaled";
-  case Format::eR16G16B16A16Sscaled:
-    return "R16G16B16A16Sscaled";
-  case Format::eR16G16B16A16Uint:
-    return "R16G16B16A16Uint";
-  case Format::eR16G16B16A16Sint:
-    return "R16G16B16A16Sint";
-  case Format::eR16G16B16A16Sfloat:
-    return "R16G16B16A16Sfloat";
-  case Format::eR32Uint:
-    return "R32Uint";
-  case Format::eR32Sint:
-    return "R32Sint";
-  case Format::eR32Sfloat:
-    return "R32Sfloat";
-  case Format::eR32G32Uint:
-    return "R32G32Uint";
-  case Format::eR32G32Sint:
-    return "R32G32Sint";
-  case Format::eR32G32Sfloat:
-    return "R32G32Sfloat";
-  case Format::eR32G32B32Uint:
-    return "R32G32B32Uint";
-  case Format::eR32G32B32Sint:
-    return "R32G32B32Sint";
-  case Format::eR32G32B32Sfloat:
-    return "R32G32B32Sfloat";
-  case Format::eR32G32B32A32Uint:
-    return "R32G32B32A32Uint";
-  case Format::eR32G32B32A32Sint:
-    return "R32G32B32A32Sint";
-  case Format::eR32G32B32A32Sfloat:
-    return "R32G32B32A32Sfloat";
-  case Format::eR64Uint:
-    return "R64Uint";
-  case Format::eR64Sint:
-    return "R64Sint";
-  case Format::eR64Sfloat:
-    return "R64Sfloat";
-  case Format::eR64G64Uint:
-    return "R64G64Uint";
-  case Format::eR64G64Sint:
-    return "R64G64Sint";
-  case Format::eR64G64Sfloat:
-    return "R64G64Sfloat";
-  case Format::eR64G64B64Uint:
-    return "R64G64B64Uint";
-  case Format::eR64G64B64Sint:
-    return "R64G64B64Sint";
-  case Format::eR64G64B64Sfloat:
-    return "R64G64B64Sfloat";
-  case Format::eR64G64B64A64Uint:
-    return "R64G64B64A64Uint";
-  case Format::eR64G64B64A64Sint:
-    return "R64G64B64A64Sint";
-  case Format::eR64G64B64A64Sfloat:
-    return "R64G64B64A64Sfloat";
-  case Format::eB10G11R11UfloatPack32:
-    return "B10G11R11UfloatPack32";
-  case Format::eE5B9G9R9UfloatPack32:
-    return "E5B9G9R9UfloatPack32";
-  case Format::eD16Unorm:
-    return "D16Unorm";
-  case Format::eX8D24UnormPack32:
-    return "X8D24UnormPack32";
-  case Format::eD32Sfloat:
-    return "D32Sfloat";
-  case Format::eS8Uint:
-    return "S8Uint";
-  case Format::eD16UnormS8Uint:
-    return "D16UnormS8Uint";
-  case Format::eD24UnormS8Uint:
-    return "D24UnormS8Uint";
-  case Format::eD32SfloatS8Uint:
-    return "D32SfloatS8Uint";
-  case Format::eBc1RgbUnormBlock:
-    return "Bc1RgbUnormBlock";
-  case Format::eBc1RgbSrgbBlock:
-    return "Bc1RgbSrgbBlock";
-  case Format::eBc1RgbaUnormBlock:
-    return "Bc1RgbaUnormBlock";
-  case Format::eBc1RgbaSrgbBlock:
-    return "Bc1RgbaSrgbBlock";
-  case Format::eBc2UnormBlock:
-    return "Bc2UnormBlock";
-  case Format::eBc2SrgbBlock:
-    return "Bc2SrgbBlock";
-  case Format::eBc3UnormBlock:
-    return "Bc3UnormBlock";
-  case Format::eBc3SrgbBlock:
-    return "Bc3SrgbBlock";
-  case Format::eBc4UnormBlock:
-    return "Bc4UnormBlock";
-  case Format::eBc4SnormBlock:
-    return "Bc4SnormBlock";
-  case Format::eBc5UnormBlock:
-    return "Bc5UnormBlock";
-  case Format::eBc5SnormBlock:
-    return "Bc5SnormBlock";
-  case Format::eBc6HUfloatBlock:
-    return "Bc6HUfloatBlock";
-  case Format::eBc6HSfloatBlock:
-    return "Bc6HSfloatBlock";
-  case Format::eBc7UnormBlock:
-    return "Bc7UnormBlock";
-  case Format::eBc7SrgbBlock:
-    return "Bc7SrgbBlock";
-  case Format::eEtc2R8G8B8UnormBlock:
-    return "Etc2R8G8B8UnormBlock";
-  case Format::eEtc2R8G8B8SrgbBlock:
-    return "Etc2R8G8B8SrgbBlock";
-  case Format::eEtc2R8G8B8A1UnormBlock:
-    return "Etc2R8G8B8A1UnormBlock";
-  case Format::eEtc2R8G8B8A1SrgbBlock:
-    return "Etc2R8G8B8A1SrgbBlock";
-  case Format::eEtc2R8G8B8A8UnormBlock:
-    return "Etc2R8G8B8A8UnormBlock";
-  case Format::eEtc2R8G8B8A8SrgbBlock:
-    return "Etc2R8G8B8A8SrgbBlock";
-  case Format::eEacR11UnormBlock:
-    return "EacR11UnormBlock";
-  case Format::eEacR11SnormBlock:
-    return "EacR11SnormBlock";
-  case Format::eEacR11G11UnormBlock:
-    return "EacR11G11UnormBlock";
-  case Format::eEacR11G11SnormBlock:
-    return "EacR11G11SnormBlock";
-  case Format::eAstc4x4UnormBlock:
-    return "Astc4x4UnormBlock";
-  case Format::eAstc4x4SrgbBlock:
-    return "Astc4x4SrgbBlock";
-  case Format::eAstc5x4UnormBlock:
-    return "Astc5x4UnormBlock";
-  case Format::eAstc5x4SrgbBlock:
-    return "Astc5x4SrgbBlock";
-  case Format::eAstc5x5UnormBlock:
-    return "Astc5x5UnormBlock";
-  case Format::eAstc5x5SrgbBlock:
-    return "Astc5x5SrgbBlock";
-  case Format::eAstc6x5UnormBlock:
-    return "Astc6x5UnormBlock";
-  case Format::eAstc6x5SrgbBlock:
-    return "Astc6x5SrgbBlock";
-  case Format::eAstc6x6UnormBlock:
-    return "Astc6x6UnormBlock";
-  case Format::eAstc6x6SrgbBlock:
-    return "Astc6x6SrgbBlock";
-  case Format::eAstc8x5UnormBlock:
-    return "Astc8x5UnormBlock";
-  case Format::eAstc8x5SrgbBlock:
-    return "Astc8x5SrgbBlock";
-  case Format::eAstc8x6UnormBlock:
-    return "Astc8x6UnormBlock";
-  case Format::eAstc8x6SrgbBlock:
-    return "Astc8x6SrgbBlock";
-  case Format::eAstc8x8UnormBlock:
-    return "Astc8x8UnormBlock";
-  case Format::eAstc8x8SrgbBlock:
-    return "Astc8x8SrgbBlock";
-  case Format::eAstc10x5UnormBlock:
-    return "Astc10x5UnormBlock";
-  case Format::eAstc10x5SrgbBlock:
-    return "Astc10x5SrgbBlock";
-  case Format::eAstc10x6UnormBlock:
-    return "Astc10x6UnormBlock";
-  case Format::eAstc10x6SrgbBlock:
-    return "Astc10x6SrgbBlock";
-  case Format::eAstc10x8UnormBlock:
-    return "Astc10x8UnormBlock";
-  case Format::eAstc10x8SrgbBlock:
-    return "Astc10x8SrgbBlock";
-  case Format::eAstc10x10UnormBlock:
-    return "Astc10x10UnormBlock";
-  case Format::eAstc10x10SrgbBlock:
-    return "Astc10x10SrgbBlock";
-  case Format::eAstc12x10UnormBlock:
-    return "Astc12x10UnormBlock";
-  case Format::eAstc12x10SrgbBlock:
-    return "Astc12x10SrgbBlock";
-  case Format::eAstc12x12UnormBlock:
-    return "Astc12x12UnormBlock";
-  case Format::eAstc12x12SrgbBlock:
-    return "Astc12x12SrgbBlock";
-  case Format::eG8B8G8R8422Unorm:
-    return "G8B8G8R8422Unorm";
-  case Format::eB8G8R8G8422Unorm:
-    return "B8G8R8G8422Unorm";
-  case Format::eG8B8R83Plane420Unorm:
-    return "G8B8R83Plane420Unorm";
-  case Format::eG8B8R82Plane420Unorm:
-    return "G8B8R82Plane420Unorm";
-  case Format::eG8B8R83Plane422Unorm:
-    return "G8B8R83Plane422Unorm";
-  case Format::eG8B8R82Plane422Unorm:
-    return "G8B8R82Plane422Unorm";
-  case Format::eG8B8R83Plane444Unorm:
-    return "G8B8R83Plane444Unorm";
-  case Format::eR10X6UnormPack16:
-    return "R10X6UnormPack16";
-  case Format::eR10X6G10X6Unorm2Pack16:
-    return "R10X6G10X6Unorm2Pack16";
-  case Format::eR10X6G10X6B10X6A10X6Unorm4Pack16:
-    return "R10X6G10X6B10X6A10X6Unorm4Pack16";
-  case Format::eG10X6B10X6G10X6R10X6422Unorm4Pack16:
-    return "G10X6B10X6G10X6R10X6422Unorm4Pack16";
-  case Format::eB10X6G10X6R10X6G10X6422Unorm4Pack16:
-    return "B10X6G10X6R10X6G10X6422Unorm4Pack16";
-  case Format::eG10X6B10X6R10X63Plane420Unorm3Pack16:
-    return "G10X6B10X6R10X63Plane420Unorm3Pack16";
-  case Format::eG10X6B10X6R10X62Plane420Unorm3Pack16:
-    return "G10X6B10X6R10X62Plane420Unorm3Pack16";
-  case Format::eG10X6B10X6R10X63Plane422Unorm3Pack16:
-    return "G10X6B10X6R10X63Plane422Unorm3Pack16";
-  case Format::eG10X6B10X6R10X62Plane422Unorm3Pack16:
-    return "G10X6B10X6R10X62Plane422Unorm3Pack16";
-  case Format::eG10X6B10X6R10X63Plane444Unorm3Pack16:
-    return "G10X6B10X6R10X63Plane444Unorm3Pack16";
-  case Format::eR12X4UnormPack16:
-    return "R12X4UnormPack16";
-  case Format::eR12X4G12X4Unorm2Pack16:
-    return "R12X4G12X4Unorm2Pack16";
-  case Format::eR12X4G12X4B12X4A12X4Unorm4Pack16:
-    return "R12X4G12X4B12X4A12X4Unorm4Pack16";
-  case Format::eG12X4B12X4G12X4R12X4422Unorm4Pack16:
-    return "G12X4B12X4G12X4R12X4422Unorm4Pack16";
-  case Format::eB12X4G12X4R12X4G12X4422Unorm4Pack16:
-    return "B12X4G12X4R12X4G12X4422Unorm4Pack16";
-  case Format::eG12X4B12X4R12X43Plane420Unorm3Pack16:
-    return "G12X4B12X4R12X43Plane420Unorm3Pack16";
-  case Format::eG12X4B12X4R12X42Plane420Unorm3Pack16:
-    return "G12X4B12X4R12X42Plane420Unorm3Pack16";
-  case Format::eG12X4B12X4R12X43Plane422Unorm3Pack16:
-    return "G12X4B12X4R12X43Plane422Unorm3Pack16";
-  case Format::eG12X4B12X4R12X42Plane422Unorm3Pack16:
-    return "G12X4B12X4R12X42Plane422Unorm3Pack16";
-  case Format::eG12X4B12X4R12X43Plane444Unorm3Pack16:
-    return "G12X4B12X4R12X43Plane444Unorm3Pack16";
-  case Format::eG16B16G16R16422Unorm:
-    return "G16B16G16R16422Unorm";
-  case Format::eB16G16R16G16422Unorm:
-    return "B16G16R16G16422Unorm";
-  case Format::eG16B16R163Plane420Unorm:
-    return "G16B16R163Plane420Unorm";
-  case Format::eG16B16R162Plane420Unorm:
-    return "G16B16R162Plane420Unorm";
-  case Format::eG16B16R163Plane422Unorm:
-    return "G16B16R163Plane422Unorm";
-  case Format::eG16B16R162Plane422Unorm:
-    return "G16B16R162Plane422Unorm";
-  case Format::eG16B16R163Plane444Unorm:
-    return "G16B16R163Plane444Unorm";
-  case Format::ePvrtc12BppUnormBlockIMG:
-    return "Pvrtc12BppUnormBlockIMG";
-  case Format::ePvrtc14BppUnormBlockIMG:
-    return "Pvrtc14BppUnormBlockIMG";
-  case Format::ePvrtc22BppUnormBlockIMG:
-    return "Pvrtc22BppUnormBlockIMG";
-  case Format::ePvrtc24BppUnormBlockIMG:
-    return "Pvrtc24BppUnormBlockIMG";
-  case Format::ePvrtc12BppSrgbBlockIMG:
-    return "Pvrtc12BppSrgbBlockIMG";
-  case Format::ePvrtc14BppSrgbBlockIMG:
-    return "Pvrtc14BppSrgbBlockIMG";
-  case Format::ePvrtc22BppSrgbBlockIMG:
-    return "Pvrtc22BppSrgbBlockIMG";
-  case Format::ePvrtc24BppSrgbBlockIMG:
-    return "Pvrtc24BppSrgbBlockIMG";
-  case Format::eAstc4x4SfloatBlockEXT:
-    return "Astc4x4SfloatBlockEXT";
-  case Format::eAstc5x4SfloatBlockEXT:
-    return "Astc5x4SfloatBlockEXT";
-  case Format::eAstc5x5SfloatBlockEXT:
-    return "Astc5x5SfloatBlockEXT";
-  case Format::eAstc6x5SfloatBlockEXT:
-    return "Astc6x5SfloatBlockEXT";
-  case Format::eAstc6x6SfloatBlockEXT:
-    return "Astc6x6SfloatBlockEXT";
-  case Format::eAstc8x5SfloatBlockEXT:
-    return "Astc8x5SfloatBlockEXT";
-  case Format::eAstc8x6SfloatBlockEXT:
-    return "Astc8x6SfloatBlockEXT";
-  case Format::eAstc8x8SfloatBlockEXT:
-    return "Astc8x8SfloatBlockEXT";
-  case Format::eAstc10x5SfloatBlockEXT:
-    return "Astc10x5SfloatBlockEXT";
-  case Format::eAstc10x6SfloatBlockEXT:
-    return "Astc10x6SfloatBlockEXT";
-  case Format::eAstc10x8SfloatBlockEXT:
-    return "Astc10x8SfloatBlockEXT";
-  case Format::eAstc10x10SfloatBlockEXT:
-    return "Astc10x10SfloatBlockEXT";
-  case Format::eAstc12x10SfloatBlockEXT:
-    return "Astc12x10SfloatBlockEXT";
-  case Format::eAstc12x12SfloatBlockEXT:
-    return "Astc12x12SfloatBlockEXT";
-  case Format::eA4R4G4B4UnormPack16EXT:
-    return "A4R4G4B4UnormPack16EXT";
-  case Format::eA4B4G4R4UnormPack16EXT:
-    return "A4B4G4R4UnormPack16EXT";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class FormatFeatureFlagBits : VkFormatFeatureFlags {
-  eSampledImage = VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT,
-  eStorageImage = VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT,
-  eStorageImageAtomic = VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT,
-  eUniformTexelBuffer = VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT,
-  eStorageTexelBuffer = VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT,
-  eStorageTexelBufferAtomic = VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT,
-  eVertexBuffer = VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT,
-  eColorAttachment = VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT,
-  eColorAttachmentBlend = VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT,
-  eDepthStencilAttachment = VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT,
-  eBlitSrc = VK_FORMAT_FEATURE_BLIT_SRC_BIT,
-  eBlitDst = VK_FORMAT_FEATURE_BLIT_DST_BIT,
-  eSampledImageFilterLinear = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT,
-  eTransferSrc = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT,
-  eTransferDst = VK_FORMAT_FEATURE_TRANSFER_DST_BIT,
-  eMidpointChromaSamples = VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT,
-  eSampledImageYcbcrConversionLinearFilter =
-      VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT,
-  eSampledImageYcbcrConversionSeparateReconstructionFilter =
-      VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT,
-  eSampledImageYcbcrConversionChromaReconstructionExplicit =
-      VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT,
-  eSampledImageYcbcrConversionChromaReconstructionExplicitForceable =
-      VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT,
-  eDisjoint = VK_FORMAT_FEATURE_DISJOINT_BIT,
-  eCositedChromaSamples = VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT,
-  eSampledImageFilterMinmax = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT,
-  eSampledImageFilterCubicIMG =
-      VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG,
-  eAccelerationStructureVertexBufferKHR =
-      VK_FORMAT_FEATURE_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR,
-  eFragmentDensityMapEXT = VK_FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT,
-  eFragmentShadingRateAttachmentKHR =
-      VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR,
-  eCositedChromaSamplesKHR = VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR,
-  eDisjointKHR = VK_FORMAT_FEATURE_DISJOINT_BIT_KHR,
-  eMidpointChromaSamplesKHR = VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR,
-  eSampledImageFilterCubicEXT =
-      VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT,
-  eSampledImageFilterMinmaxEXT =
-      VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT,
-  eSampledImageYcbcrConversionChromaReconstructionExplicitKHR =
-      VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR,
-  eSampledImageYcbcrConversionChromaReconstructionExplicitForceableKHR =
-      VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR,
-  eSampledImageYcbcrConversionLinearFilterKHR =
-      VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR,
-  eSampledImageYcbcrConversionSeparateReconstructionFilterKHR =
-      VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR,
-  eTransferDstKHR = VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR,
-  eTransferSrcKHR = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR
-};
-
-VULKAN_HPP_INLINE std::string to_string(FormatFeatureFlagBits value) {
-  switch (value) {
-  case FormatFeatureFlagBits::eSampledImage:
-    return "SampledImage";
-  case FormatFeatureFlagBits::eStorageImage:
-    return "StorageImage";
-  case FormatFeatureFlagBits::eStorageImageAtomic:
-    return "StorageImageAtomic";
-  case FormatFeatureFlagBits::eUniformTexelBuffer:
-    return "UniformTexelBuffer";
-  case FormatFeatureFlagBits::eStorageTexelBuffer:
-    return "StorageTexelBuffer";
-  case FormatFeatureFlagBits::eStorageTexelBufferAtomic:
-    return "StorageTexelBufferAtomic";
-  case FormatFeatureFlagBits::eVertexBuffer:
-    return "VertexBuffer";
-  case FormatFeatureFlagBits::eColorAttachment:
-    return "ColorAttachment";
-  case FormatFeatureFlagBits::eColorAttachmentBlend:
-    return "ColorAttachmentBlend";
-  case FormatFeatureFlagBits::eDepthStencilAttachment:
-    return "DepthStencilAttachment";
-  case FormatFeatureFlagBits::eBlitSrc:
-    return "BlitSrc";
-  case FormatFeatureFlagBits::eBlitDst:
-    return "BlitDst";
-  case FormatFeatureFlagBits::eSampledImageFilterLinear:
-    return "SampledImageFilterLinear";
-  case FormatFeatureFlagBits::eTransferSrc:
-    return "TransferSrc";
-  case FormatFeatureFlagBits::eTransferDst:
-    return "TransferDst";
-  case FormatFeatureFlagBits::eMidpointChromaSamples:
-    return "MidpointChromaSamples";
-  case FormatFeatureFlagBits::eSampledImageYcbcrConversionLinearFilter:
-    return "SampledImageYcbcrConversionLinearFilter";
-  case FormatFeatureFlagBits::
-      eSampledImageYcbcrConversionSeparateReconstructionFilter:
-    return "SampledImageYcbcrConversionSeparateReconstructionFilter";
-  case FormatFeatureFlagBits::
-      eSampledImageYcbcrConversionChromaReconstructionExplicit:
-    return "SampledImageYcbcrConversionChromaReconstructionExplicit";
-  case FormatFeatureFlagBits::
-      eSampledImageYcbcrConversionChromaReconstructionExplicitForceable:
-    return "SampledImageYcbcrConversionChromaReconstructionExplicitForceable";
-  case FormatFeatureFlagBits::eDisjoint:
-    return "Disjoint";
-  case FormatFeatureFlagBits::eCositedChromaSamples:
-    return "CositedChromaSamples";
-  case FormatFeatureFlagBits::eSampledImageFilterMinmax:
-    return "SampledImageFilterMinmax";
-  case FormatFeatureFlagBits::eSampledImageFilterCubicIMG:
-    return "SampledImageFilterCubicIMG";
-  case FormatFeatureFlagBits::eAccelerationStructureVertexBufferKHR:
-    return "AccelerationStructureVertexBufferKHR";
-  case FormatFeatureFlagBits::eFragmentDensityMapEXT:
-    return "FragmentDensityMapEXT";
-  case FormatFeatureFlagBits::eFragmentShadingRateAttachmentKHR:
-    return "FragmentShadingRateAttachmentKHR";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class FragmentShadingRateCombinerOpKHR {
-  eKeep = VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR,
-  eReplace = VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR,
-  eMin = VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_KHR,
-  eMax = VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_KHR,
-  eMul = VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR
-};
-
-VULKAN_HPP_INLINE std::string
-to_string(FragmentShadingRateCombinerOpKHR value) {
-  switch (value) {
-  case FragmentShadingRateCombinerOpKHR::eKeep:
-    return "Keep";
-  case FragmentShadingRateCombinerOpKHR::eReplace:
-    return "Replace";
-  case FragmentShadingRateCombinerOpKHR::eMin:
-    return "Min";
-  case FragmentShadingRateCombinerOpKHR::eMax:
-    return "Max";
-  case FragmentShadingRateCombinerOpKHR::eMul:
-    return "Mul";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class FragmentShadingRateNV {
-  e1InvocationPerPixel = VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_PIXEL_NV,
-  e1InvocationPer1X2Pixels =
-      VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_1X2_PIXELS_NV,
-  e1InvocationPer2X1Pixels =
-      VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X1_PIXELS_NV,
-  e1InvocationPer2X2Pixels =
-      VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X2_PIXELS_NV,
-  e1InvocationPer2X4Pixels =
-      VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X4_PIXELS_NV,
-  e1InvocationPer4X2Pixels =
-      VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X2_PIXELS_NV,
-  e1InvocationPer4X4Pixels =
-      VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X4_PIXELS_NV,
-  e2InvocationsPerPixel = VK_FRAGMENT_SHADING_RATE_2_INVOCATIONS_PER_PIXEL_NV,
-  e4InvocationsPerPixel = VK_FRAGMENT_SHADING_RATE_4_INVOCATIONS_PER_PIXEL_NV,
-  e8InvocationsPerPixel = VK_FRAGMENT_SHADING_RATE_8_INVOCATIONS_PER_PIXEL_NV,
-  e16InvocationsPerPixel = VK_FRAGMENT_SHADING_RATE_16_INVOCATIONS_PER_PIXEL_NV,
-  eNoInvocations = VK_FRAGMENT_SHADING_RATE_NO_INVOCATIONS_NV
-};
-
-VULKAN_HPP_INLINE std::string to_string(FragmentShadingRateNV value) {
-  switch (value) {
-  case FragmentShadingRateNV::e1InvocationPerPixel:
-    return "1InvocationPerPixel";
-  case FragmentShadingRateNV::e1InvocationPer1X2Pixels:
-    return "1InvocationPer1X2Pixels";
-  case FragmentShadingRateNV::e1InvocationPer2X1Pixels:
-    return "1InvocationPer2X1Pixels";
-  case FragmentShadingRateNV::e1InvocationPer2X2Pixels:
-    return "1InvocationPer2X2Pixels";
-  case FragmentShadingRateNV::e1InvocationPer2X4Pixels:
-    return "1InvocationPer2X4Pixels";
-  case FragmentShadingRateNV::e1InvocationPer4X2Pixels:
-    return "1InvocationPer4X2Pixels";
-  case FragmentShadingRateNV::e1InvocationPer4X4Pixels:
-    return "1InvocationPer4X4Pixels";
-  case FragmentShadingRateNV::e2InvocationsPerPixel:
-    return "2InvocationsPerPixel";
-  case FragmentShadingRateNV::e4InvocationsPerPixel:
-    return "4InvocationsPerPixel";
-  case FragmentShadingRateNV::e8InvocationsPerPixel:
-    return "8InvocationsPerPixel";
-  case FragmentShadingRateNV::e16InvocationsPerPixel:
-    return "16InvocationsPerPixel";
-  case FragmentShadingRateNV::eNoInvocations:
-    return "NoInvocations";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class FragmentShadingRateTypeNV {
-  eFragmentSize = VK_FRAGMENT_SHADING_RATE_TYPE_FRAGMENT_SIZE_NV,
-  eEnums = VK_FRAGMENT_SHADING_RATE_TYPE_ENUMS_NV
-};
-
-VULKAN_HPP_INLINE std::string to_string(FragmentShadingRateTypeNV value) {
-  switch (value) {
-  case FragmentShadingRateTypeNV::eFragmentSize:
-    return "FragmentSize";
-  case FragmentShadingRateTypeNV::eEnums:
-    return "Enums";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class FramebufferCreateFlagBits : VkFramebufferCreateFlags {
-  eImageless = VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT,
-  eImagelessKHR = VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR
-};
-
-VULKAN_HPP_INLINE std::string to_string(FramebufferCreateFlagBits value) {
-  switch (value) {
-  case FramebufferCreateFlagBits::eImageless:
-    return "Imageless";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class FrontFace {
-  eCounterClockwise = VK_FRONT_FACE_COUNTER_CLOCKWISE,
-  eClockwise = VK_FRONT_FACE_CLOCKWISE
-};
-
-VULKAN_HPP_INLINE std::string to_string(FrontFace value) {
-  switch (value) {
-  case FrontFace::eCounterClockwise:
-    return "CounterClockwise";
-  case FrontFace::eClockwise:
-    return "Clockwise";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-#if defined(VK_USE_PLATFORM_WIN32_KHR)
-enum class FullScreenExclusiveEXT {
-  eDefault = VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT,
-  eAllowed = VK_FULL_SCREEN_EXCLUSIVE_ALLOWED_EXT,
-  eDisallowed = VK_FULL_SCREEN_EXCLUSIVE_DISALLOWED_EXT,
-  eApplicationControlled = VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT
-};
-
-VULKAN_HPP_INLINE std::string to_string(FullScreenExclusiveEXT value) {
-  switch (value) {
-  case FullScreenExclusiveEXT::eDefault:
-    return "Default";
-  case FullScreenExclusiveEXT::eAllowed:
-    return "Allowed";
-  case FullScreenExclusiveEXT::eDisallowed:
-    return "Disallowed";
-  case FullScreenExclusiveEXT::eApplicationControlled:
-    return "ApplicationControlled";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-enum class GeometryFlagBitsKHR : VkGeometryFlagsKHR {
-  eOpaque = VK_GEOMETRY_OPAQUE_BIT_KHR,
-  eNoDuplicateAnyHitInvocation =
-      VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR
-};
-using GeometryFlagBitsNV = GeometryFlagBitsKHR;
-
-VULKAN_HPP_INLINE std::string to_string(GeometryFlagBitsKHR value) {
-  switch (value) {
-  case GeometryFlagBitsKHR::eOpaque:
-    return "Opaque";
-  case GeometryFlagBitsKHR::eNoDuplicateAnyHitInvocation:
-    return "NoDuplicateAnyHitInvocation";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class GeometryInstanceFlagBitsKHR : VkGeometryInstanceFlagsKHR {
-  eTriangleFacingCullDisable =
-      VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR,
-  eTriangleFrontCounterclockwise =
-      VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR,
-  eForceOpaque = VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR,
-  eForceNoOpaque = VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR,
-  eTriangleCullDisable = VK_GEOMETRY_INSTANCE_TRIANGLE_CULL_DISABLE_BIT_NV
-};
-using GeometryInstanceFlagBitsNV = GeometryInstanceFlagBitsKHR;
-
-VULKAN_HPP_INLINE std::string to_string(GeometryInstanceFlagBitsKHR value) {
-  switch (value) {
-  case GeometryInstanceFlagBitsKHR::eTriangleFacingCullDisable:
-    return "TriangleFacingCullDisable";
-  case GeometryInstanceFlagBitsKHR::eTriangleFrontCounterclockwise:
-    return "TriangleFrontCounterclockwise";
-  case GeometryInstanceFlagBitsKHR::eForceOpaque:
-    return "ForceOpaque";
-  case GeometryInstanceFlagBitsKHR::eForceNoOpaque:
-    return "ForceNoOpaque";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class GeometryTypeKHR {
-  eTriangles = VK_GEOMETRY_TYPE_TRIANGLES_KHR,
-  eAabbs = VK_GEOMETRY_TYPE_AABBS_KHR,
-  eInstances = VK_GEOMETRY_TYPE_INSTANCES_KHR
-};
-using GeometryTypeNV = GeometryTypeKHR;
-
-VULKAN_HPP_INLINE std::string to_string(GeometryTypeKHR value) {
-  switch (value) {
-  case GeometryTypeKHR::eTriangles:
-    return "Triangles";
-  case GeometryTypeKHR::eAabbs:
-    return "Aabbs";
-  case GeometryTypeKHR::eInstances:
-    return "Instances";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class ImageAspectFlagBits : VkImageAspectFlags {
-  eColor = VK_IMAGE_ASPECT_COLOR_BIT,
-  eDepth = VK_IMAGE_ASPECT_DEPTH_BIT,
-  eStencil = VK_IMAGE_ASPECT_STENCIL_BIT,
-  eMetadata = VK_IMAGE_ASPECT_METADATA_BIT,
-  ePlane0 = VK_IMAGE_ASPECT_PLANE_0_BIT,
-  ePlane1 = VK_IMAGE_ASPECT_PLANE_1_BIT,
-  ePlane2 = VK_IMAGE_ASPECT_PLANE_2_BIT,
-  eMemoryPlane0EXT = VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT,
-  eMemoryPlane1EXT = VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT,
-  eMemoryPlane2EXT = VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT,
-  eMemoryPlane3EXT = VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT,
-  ePlane0KHR = VK_IMAGE_ASPECT_PLANE_0_BIT_KHR,
-  ePlane1KHR = VK_IMAGE_ASPECT_PLANE_1_BIT_KHR,
-  ePlane2KHR = VK_IMAGE_ASPECT_PLANE_2_BIT_KHR
-};
-
-VULKAN_HPP_INLINE std::string to_string(ImageAspectFlagBits value) {
-  switch (value) {
-  case ImageAspectFlagBits::eColor:
-    return "Color";
-  case ImageAspectFlagBits::eDepth:
-    return "Depth";
-  case ImageAspectFlagBits::eStencil:
-    return "Stencil";
-  case ImageAspectFlagBits::eMetadata:
-    return "Metadata";
-  case ImageAspectFlagBits::ePlane0:
-    return "Plane0";
-  case ImageAspectFlagBits::ePlane1:
-    return "Plane1";
-  case ImageAspectFlagBits::ePlane2:
-    return "Plane2";
-  case ImageAspectFlagBits::eMemoryPlane0EXT:
-    return "MemoryPlane0EXT";
-  case ImageAspectFlagBits::eMemoryPlane1EXT:
-    return "MemoryPlane1EXT";
-  case ImageAspectFlagBits::eMemoryPlane2EXT:
-    return "MemoryPlane2EXT";
-  case ImageAspectFlagBits::eMemoryPlane3EXT:
-    return "MemoryPlane3EXT";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-#if defined(VK_USE_PLATFORM_FUCHSIA)
-enum class
-    ImageConstraintsInfoFlagBitsFUCHSIA : VkImageConstraintsInfoFlagsFUCHSIA {
-      eCpuReadRarely = VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_RARELY_FUCHSIA,
-      eCpuReadOften = VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_OFTEN_FUCHSIA,
-      eCpuWriteRarely = VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_RARELY_FUCHSIA,
-      eCpuWriteOften = VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_OFTEN_FUCHSIA,
-      eProtectedOptional = VK_IMAGE_CONSTRAINTS_INFO_PROTECTED_OPTIONAL_FUCHSIA
-    };
-
-VULKAN_HPP_INLINE std::string
-to_string(ImageConstraintsInfoFlagBitsFUCHSIA value) {
-  switch (value) {
-  case ImageConstraintsInfoFlagBitsFUCHSIA::eCpuReadRarely:
-    return "CpuReadRarely";
-  case ImageConstraintsInfoFlagBitsFUCHSIA::eCpuReadOften:
-    return "CpuReadOften";
-  case ImageConstraintsInfoFlagBitsFUCHSIA::eCpuWriteRarely:
-    return "CpuWriteRarely";
-  case ImageConstraintsInfoFlagBitsFUCHSIA::eCpuWriteOften:
-    return "CpuWriteOften";
-  case ImageConstraintsInfoFlagBitsFUCHSIA::eProtectedOptional:
-    return "ProtectedOptional";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-#endif /*VK_USE_PLATFORM_FUCHSIA*/
-
-enum class ImageCreateFlagBits : VkImageCreateFlags {
-  // clang-format off
-      eSparseBinding = VK_IMAGE_CREATE_SPARSE_BINDING_BIT
-    , eSparseResidency = VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT
-    , eSparseAliased = VK_IMAGE_CREATE_SPARSE_ALIASED_BIT
-    , eMutableFormat = VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT
-    , eCubeCompatible = VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT
-    , eAlias = VK_IMAGE_CREATE_ALIAS_BIT
-    , eSplitInstanceBindRegions = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT
-    , e2DArrayCompatible = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT
-    , eBlockTexelViewCompatible = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT
-    , eExtendedUsage = VK_IMAGE_CREATE_EXTENDED_USAGE_BIT
-    , eProtected = VK_IMAGE_CREATE_PROTECTED_BIT
-    , eDisjoint = VK_IMAGE_CREATE_DISJOINT_BIT
-    , eCornerSampledNV = VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV
-    , eSampleLocationsCompatibleDepthEXT = VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT
-    , eSubsampledEXT = VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT
-#if defined( VK_USE_PLATFORM_FUCHSIA )
-    , eCompactFUCHSIA = VK_IMAGE_CREATE_COMPACT_BIT_FUCHSIA
-#endif /*VK_USE_PLATFORM_FUCHSIA*/
-    , e2DArrayCompatibleKHR = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR
-    , eAliasKHR = VK_IMAGE_CREATE_ALIAS_BIT_KHR
-    , eBlockTexelViewCompatibleKHR = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR
-    , eDisjointKHR = VK_IMAGE_CREATE_DISJOINT_BIT_KHR
-    , eExtendedUsageKHR = VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR
-    , eSplitInstanceBindRegionsKHR = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR
-  // clang-format on
-};
-
-VULKAN_HPP_INLINE std::string to_string(ImageCreateFlagBits value) {
-  switch (value) {
-  case ImageCreateFlagBits::eSparseBinding:
-    return "SparseBinding";
-  case ImageCreateFlagBits::eSparseResidency:
-    return "SparseResidency";
-  case ImageCreateFlagBits::eSparseAliased:
-    return "SparseAliased";
-  case ImageCreateFlagBits::eMutableFormat:
-    return "MutableFormat";
-  case ImageCreateFlagBits::eCubeCompatible:
-    return "CubeCompatible";
-  case ImageCreateFlagBits::eAlias:
-    return "Alias";
-  case ImageCreateFlagBits::eSplitInstanceBindRegions:
-    return "SplitInstanceBindRegions";
-  case ImageCreateFlagBits::e2DArrayCompatible:
-    return "2DArrayCompatible";
-  case ImageCreateFlagBits::eBlockTexelViewCompatible:
-    return "BlockTexelViewCompatible";
-  case ImageCreateFlagBits::eExtendedUsage:
-    return "ExtendedUsage";
-  case ImageCreateFlagBits::eProtected:
-    return "Protected";
-  case ImageCreateFlagBits::eDisjoint:
-    return "Disjoint";
-  case ImageCreateFlagBits::eCornerSampledNV:
-    return "CornerSampledNV";
-  case ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT:
-    return "SampleLocationsCompatibleDepthEXT";
-  case ImageCreateFlagBits::eSubsampledEXT:
-    return "SubsampledEXT";
-#if defined(VK_USE_PLATFORM_FUCHSIA)
-  case ImageCreateFlagBits::eCompactFUCHSIA:
-    return "CompactFUCHSIA";
-#endif /*VK_USE_PLATFORM_FUCHSIA*/
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-#if defined(VK_USE_PLATFORM_FUCHSIA)
-enum class
-    ImageFormatConstraintsFlagBitsFUCHSIA : VkImageFormatConstraintsFlagsFUCHSIA {
-    };
-
-VULKAN_HPP_INLINE std::string to_string(ImageFormatConstraintsFlagBitsFUCHSIA) {
-  return "(void)";
-}
-#endif /*VK_USE_PLATFORM_FUCHSIA*/
-
-enum class ImageLayout {
-  eUndefined = VK_IMAGE_LAYOUT_UNDEFINED,
-  eGeneral = VK_IMAGE_LAYOUT_GENERAL,
-  eColorAttachmentOptimal = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
-  eDepthStencilAttachmentOptimal =
-      VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
-  eDepthStencilReadOnlyOptimal =
-      VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL,
-  eShaderReadOnlyOptimal = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
-  eTransferSrcOptimal = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
-  eTransferDstOptimal = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
-  ePreinitialized = VK_IMAGE_LAYOUT_PREINITIALIZED,
-  eDepthReadOnlyStencilAttachmentOptimal =
-      VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL,
-  eDepthAttachmentStencilReadOnlyOptimal =
-      VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL,
-  eDepthAttachmentOptimal = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL,
-  eDepthReadOnlyOptimal = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL,
-  eStencilAttachmentOptimal = VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL,
-  eStencilReadOnlyOptimal = VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL,
-  ePresentSrcKHR = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
-  eSharedPresentKHR = VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR,
-  eShadingRateOptimalNV = VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV,
-  eFragmentDensityMapOptimalEXT =
-      VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT,
-  eReadOnlyOptimalKHR = VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL_KHR,
-  eAttachmentOptimalKHR = VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR,
-  eDepthAttachmentOptimalKHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL_KHR,
-  eDepthAttachmentStencilReadOnlyOptimalKHR =
-      VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR,
-  eDepthReadOnlyOptimalKHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL_KHR,
-  eDepthReadOnlyStencilAttachmentOptimalKHR =
-      VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR,
-  eFragmentShadingRateAttachmentOptimalKHR =
-      VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR,
-  eStencilAttachmentOptimalKHR = VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL_KHR,
-  eStencilReadOnlyOptimalKHR = VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL_KHR
-};
-
-VULKAN_HPP_INLINE std::string to_string(ImageLayout value) {
-  switch (value) {
-  case ImageLayout::eUndefined:
-    return "Undefined";
-  case ImageLayout::eGeneral:
-    return "General";
-  case ImageLayout::eColorAttachmentOptimal:
-    return "ColorAttachmentOptimal";
-  case ImageLayout::eDepthStencilAttachmentOptimal:
-    return "DepthStencilAttachmentOptimal";
-  case ImageLayout::eDepthStencilReadOnlyOptimal:
-    return "DepthStencilReadOnlyOptimal";
-  case ImageLayout::eShaderReadOnlyOptimal:
-    return "ShaderReadOnlyOptimal";
-  case ImageLayout::eTransferSrcOptimal:
-    return "TransferSrcOptimal";
-  case ImageLayout::eTransferDstOptimal:
-    return "TransferDstOptimal";
-  case ImageLayout::ePreinitialized:
-    return "Preinitialized";
-  case ImageLayout::eDepthReadOnlyStencilAttachmentOptimal:
-    return "DepthReadOnlyStencilAttachmentOptimal";
-  case ImageLayout::eDepthAttachmentStencilReadOnlyOptimal:
-    return "DepthAttachmentStencilReadOnlyOptimal";
-  case ImageLayout::eDepthAttachmentOptimal:
-    return "DepthAttachmentOptimal";
-  case ImageLayout::eDepthReadOnlyOptimal:
-    return "DepthReadOnlyOptimal";
-  case ImageLayout::eStencilAttachmentOptimal:
-    return "StencilAttachmentOptimal";
-  case ImageLayout::eStencilReadOnlyOptimal:
-    return "StencilReadOnlyOptimal";
-  case ImageLayout::ePresentSrcKHR:
-    return "PresentSrcKHR";
-  case ImageLayout::eSharedPresentKHR:
-    return "SharedPresentKHR";
-  case ImageLayout::eShadingRateOptimalNV:
-    return "ShadingRateOptimalNV";
-  case ImageLayout::eFragmentDensityMapOptimalEXT:
-    return "FragmentDensityMapOptimalEXT";
-  case ImageLayout::eReadOnlyOptimalKHR:
-    return "ReadOnlyOptimalKHR";
-  case ImageLayout::eAttachmentOptimalKHR:
-    return "AttachmentOptimalKHR";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class ImageTiling {
-  eOptimal = VK_IMAGE_TILING_OPTIMAL,
-  eLinear = VK_IMAGE_TILING_LINEAR,
-  eDrmFormatModifierEXT = VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT
-};
-
-VULKAN_HPP_INLINE std::string to_string(ImageTiling value) {
-  switch (value) {
-  case ImageTiling::eOptimal:
-    return "Optimal";
-  case ImageTiling::eLinear:
-    return "Linear";
-  case ImageTiling::eDrmFormatModifierEXT:
-    return "DrmFormatModifierEXT";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class ImageType {
-  e1D = VK_IMAGE_TYPE_1D,
-  e2D = VK_IMAGE_TYPE_2D,
-  e3D = VK_IMAGE_TYPE_3D
-};
-
-VULKAN_HPP_INLINE std::string to_string(ImageType value) {
-  switch (value) {
-  case ImageType::e1D:
-    return "1D";
-  case ImageType::e2D:
-    return "2D";
-  case ImageType::e3D:
-    return "3D";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class ImageUsageFlagBits : VkImageUsageFlags {
-  eTransferSrc = VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
-  eTransferDst = VK_IMAGE_USAGE_TRANSFER_DST_BIT,
-  eSampled = VK_IMAGE_USAGE_SAMPLED_BIT,
-  eStorage = VK_IMAGE_USAGE_STORAGE_BIT,
-  eColorAttachment = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
-  eDepthStencilAttachment = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
-  eTransientAttachment = VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT,
-  eInputAttachment = VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT,
-  eShadingRateImageNV = VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV,
-  eFragmentDensityMapEXT = VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT,
-  eFragmentShadingRateAttachmentKHR =
-      VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR
-};
-
-VULKAN_HPP_INLINE std::string to_string(ImageUsageFlagBits value) {
-  switch (value) {
-  case ImageUsageFlagBits::eTransferSrc:
-    return "TransferSrc";
-  case ImageUsageFlagBits::eTransferDst:
-    return "TransferDst";
-  case ImageUsageFlagBits::eSampled:
-    return "Sampled";
-  case ImageUsageFlagBits::eStorage:
-    return "Storage";
-  case ImageUsageFlagBits::eColorAttachment:
-    return "ColorAttachment";
-  case ImageUsageFlagBits::eDepthStencilAttachment:
-    return "DepthStencilAttachment";
-  case ImageUsageFlagBits::eTransientAttachment:
-    return "TransientAttachment";
-  case ImageUsageFlagBits::eInputAttachment:
-    return "InputAttachment";
-  case ImageUsageFlagBits::eShadingRateImageNV:
-    return "ShadingRateImageNV";
-  case ImageUsageFlagBits::eFragmentDensityMapEXT:
-    return "FragmentDensityMapEXT";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class ImageViewCreateFlagBits : VkImageViewCreateFlags {
-  eFragmentDensityMapDynamicEXT =
-      VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT,
-  eFragmentDensityMapDeferredEXT =
-      VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DEFERRED_BIT_EXT
-};
-
-VULKAN_HPP_INLINE std::string to_string(ImageViewCreateFlagBits value) {
-  switch (value) {
-  case ImageViewCreateFlagBits::eFragmentDensityMapDynamicEXT:
-    return "FragmentDensityMapDynamicEXT";
-  case ImageViewCreateFlagBits::eFragmentDensityMapDeferredEXT:
-    return "FragmentDensityMapDeferredEXT";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class ImageViewType {
-  e1D = VK_IMAGE_VIEW_TYPE_1D,
-  e2D = VK_IMAGE_VIEW_TYPE_2D,
-  e3D = VK_IMAGE_VIEW_TYPE_3D,
-  eCube = VK_IMAGE_VIEW_TYPE_CUBE,
-  e1DArray = VK_IMAGE_VIEW_TYPE_1D_ARRAY,
-  e2DArray = VK_IMAGE_VIEW_TYPE_2D_ARRAY,
-  eCubeArray = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY
-};
-
-VULKAN_HPP_INLINE std::string to_string(ImageViewType value) {
-  switch (value) {
-  case ImageViewType::e1D:
-    return "1D";
-  case ImageViewType::e2D:
-    return "2D";
-  case ImageViewType::e3D:
-    return "3D";
-  case ImageViewType::eCube:
-    return "Cube";
-  case ImageViewType::e1DArray:
-    return "1DArray";
-  case ImageViewType::e2DArray:
-    return "2DArray";
-  case ImageViewType::eCubeArray:
-    return "CubeArray";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class IndexType {
-  eUint16 = VK_INDEX_TYPE_UINT16,
-  eUint32 = VK_INDEX_TYPE_UINT32,
-  eNoneKHR = VK_INDEX_TYPE_NONE_KHR,
-  eUint8EXT = VK_INDEX_TYPE_UINT8_EXT,
-  eNoneNV = VK_INDEX_TYPE_NONE_NV
-};
-
-VULKAN_HPP_INLINE std::string to_string(IndexType value) {
-  switch (value) {
-  case IndexType::eUint16:
-    return "Uint16";
-  case IndexType::eUint32:
-    return "Uint32";
-  case IndexType::eNoneKHR:
-    return "NoneKHR";
-  case IndexType::eUint8EXT:
-    return "Uint8EXT";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class
-    IndirectCommandsLayoutUsageFlagBitsNV : VkIndirectCommandsLayoutUsageFlagsNV {
-      eExplicitPreprocess =
-          VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_NV,
-      eIndexedSequences =
-          VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NV,
-      eUnorderedSequences =
-          VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NV
-    };
-
-VULKAN_HPP_INLINE std::string
-to_string(IndirectCommandsLayoutUsageFlagBitsNV value) {
-  switch (value) {
-  case IndirectCommandsLayoutUsageFlagBitsNV::eExplicitPreprocess:
-    return "ExplicitPreprocess";
-  case IndirectCommandsLayoutUsageFlagBitsNV::eIndexedSequences:
-    return "IndexedSequences";
-  case IndirectCommandsLayoutUsageFlagBitsNV::eUnorderedSequences:
-    return "UnorderedSequences";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class IndirectCommandsTokenTypeNV {
-  eShaderGroup = VK_INDIRECT_COMMANDS_TOKEN_TYPE_SHADER_GROUP_NV,
-  eStateFlags = VK_INDIRECT_COMMANDS_TOKEN_TYPE_STATE_FLAGS_NV,
-  eIndexBuffer = VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NV,
-  eVertexBuffer = VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NV,
-  ePushConstant = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NV,
-  eDrawIndexed = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NV,
-  eDraw = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NV,
-  eDrawTasks = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_TASKS_NV
-};
-
-VULKAN_HPP_INLINE std::string to_string(IndirectCommandsTokenTypeNV value) {
-  switch (value) {
-  case IndirectCommandsTokenTypeNV::eShaderGroup:
-    return "ShaderGroup";
-  case IndirectCommandsTokenTypeNV::eStateFlags:
-    return "StateFlags";
-  case IndirectCommandsTokenTypeNV::eIndexBuffer:
-    return "IndexBuffer";
-  case IndirectCommandsTokenTypeNV::eVertexBuffer:
-    return "VertexBuffer";
-  case IndirectCommandsTokenTypeNV::ePushConstant:
-    return "PushConstant";
-  case IndirectCommandsTokenTypeNV::eDrawIndexed:
-    return "DrawIndexed";
-  case IndirectCommandsTokenTypeNV::eDraw:
-    return "Draw";
-  case IndirectCommandsTokenTypeNV::eDrawTasks:
-    return "DrawTasks";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class IndirectStateFlagBitsNV : VkIndirectStateFlagsNV {
-  eFlagFrontface = VK_INDIRECT_STATE_FLAG_FRONTFACE_BIT_NV
-};
-
-VULKAN_HPP_INLINE std::string to_string(IndirectStateFlagBitsNV value) {
-  switch (value) {
-  case IndirectStateFlagBitsNV::eFlagFrontface:
-    return "FlagFrontface";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class InstanceCreateFlagBits {};
-
-VULKAN_HPP_INLINE std::string to_string(InstanceCreateFlagBits) {
-  return "(void)";
-}
-
-enum class InternalAllocationType {
-  eExecutable = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE
-};
-
-VULKAN_HPP_INLINE std::string to_string(InternalAllocationType value) {
-  switch (value) {
-  case InternalAllocationType::eExecutable:
-    return "Executable";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class LineRasterizationModeEXT {
-  eDefault = VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT,
-  eRectangular = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT,
-  eBresenham = VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT,
-  eRectangularSmooth = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT
-};
-
-VULKAN_HPP_INLINE std::string to_string(LineRasterizationModeEXT value) {
-  switch (value) {
-  case LineRasterizationModeEXT::eDefault:
-    return "Default";
-  case LineRasterizationModeEXT::eRectangular:
-    return "Rectangular";
-  case LineRasterizationModeEXT::eBresenham:
-    return "Bresenham";
-  case LineRasterizationModeEXT::eRectangularSmooth:
-    return "RectangularSmooth";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class LogicOp {
-  eClear = VK_LOGIC_OP_CLEAR,
-  eAnd = VK_LOGIC_OP_AND,
-  eAndReverse = VK_LOGIC_OP_AND_REVERSE,
-  eCopy = VK_LOGIC_OP_COPY,
-  eAndInverted = VK_LOGIC_OP_AND_INVERTED,
-  eNoOp = VK_LOGIC_OP_NO_OP,
-  eXor = VK_LOGIC_OP_XOR,
-  eOr = VK_LOGIC_OP_OR,
-  eNor = VK_LOGIC_OP_NOR,
-  eEquivalent = VK_LOGIC_OP_EQUIVALENT,
-  eInvert = VK_LOGIC_OP_INVERT,
-  eOrReverse = VK_LOGIC_OP_OR_REVERSE,
-  eCopyInverted = VK_LOGIC_OP_COPY_INVERTED,
-  eOrInverted = VK_LOGIC_OP_OR_INVERTED,
-  eNand = VK_LOGIC_OP_NAND,
-  eSet = VK_LOGIC_OP_SET
-};
-
-VULKAN_HPP_INLINE std::string to_string(LogicOp value) {
-  switch (value) {
-  case LogicOp::eClear:
-    return "Clear";
-  case LogicOp::eAnd:
-    return "And";
-  case LogicOp::eAndReverse:
-    return "AndReverse";
-  case LogicOp::eCopy:
-    return "Copy";
-  case LogicOp::eAndInverted:
-    return "AndInverted";
-  case LogicOp::eNoOp:
-    return "NoOp";
-  case LogicOp::eXor:
-    return "Xor";
-  case LogicOp::eOr:
-    return "Or";
-  case LogicOp::eNor:
-    return "Nor";
-  case LogicOp::eEquivalent:
-    return "Equivalent";
-  case LogicOp::eInvert:
-    return "Invert";
-  case LogicOp::eOrReverse:
-    return "OrReverse";
-  case LogicOp::eCopyInverted:
-    return "CopyInverted";
-  case LogicOp::eOrInverted:
-    return "OrInverted";
-  case LogicOp::eNand:
-    return "Nand";
-  case LogicOp::eSet:
-    return "Set";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class MemoryAllocateFlagBits : VkMemoryAllocateFlags {
-  eDeviceMask = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT,
-  eDeviceAddress = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT,
-  eDeviceAddressCaptureReplay =
-      VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT
-};
-using MemoryAllocateFlagBitsKHR = MemoryAllocateFlagBits;
-
-VULKAN_HPP_INLINE std::string to_string(MemoryAllocateFlagBits value) {
-  switch (value) {
-  case MemoryAllocateFlagBits::eDeviceMask:
-    return "DeviceMask";
-  case MemoryAllocateFlagBits::eDeviceAddress:
-    return "DeviceAddress";
-  case MemoryAllocateFlagBits::eDeviceAddressCaptureReplay:
-    return "DeviceAddressCaptureReplay";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class MemoryHeapFlagBits : VkMemoryHeapFlags {
-  eDeviceLocal = VK_MEMORY_HEAP_DEVICE_LOCAL_BIT,
-  eMultiInstance = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT,
-  eMultiInstanceKHR = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHR
-};
-
-VULKAN_HPP_INLINE std::string to_string(MemoryHeapFlagBits value) {
-  switch (value) {
-  case MemoryHeapFlagBits::eDeviceLocal:
-    return "DeviceLocal";
-  case MemoryHeapFlagBits::eMultiInstance:
-    return "MultiInstance";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-#if defined(VK_USE_PLATFORM_FUCHSIA)
-enum class MemoryOpFlagBitsFUCHSIA : VkMemoryOpFlagsFUCHSIA {
-  eUnpin = VK_MEMORY_OP_UNPIN_BIT_FUCHSIA,
-  eDecommit = VK_MEMORY_OP_DECOMMIT_BIT_FUCHSIA,
-  ePin = VK_MEMORY_OP_PIN_BIT_FUCHSIA,
-  eCommit = VK_MEMORY_OP_COMMIT_BIT_FUCHSIA,
-  eLock = VK_MEMORY_OP_LOCK_BIT_FUCHSIA,
-  eUnlock = VK_MEMORY_OP_UNLOCK_BIT_FUCHSIA
-};
-
-VULKAN_HPP_INLINE std::string to_string(MemoryOpFlagBitsFUCHSIA value) {
-  switch (value) {
-  case MemoryOpFlagBitsFUCHSIA::eUnpin:
-    return "Unpin";
-  case MemoryOpFlagBitsFUCHSIA::eDecommit:
-    return "Decommit";
-  case MemoryOpFlagBitsFUCHSIA::ePin:
-    return "Pin";
-  case MemoryOpFlagBitsFUCHSIA::eCommit:
-    return "Commit";
-  case MemoryOpFlagBitsFUCHSIA::eLock:
-    return "Lock";
-  case MemoryOpFlagBitsFUCHSIA::eUnlock:
-    return "Unlock";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-#endif /*VK_USE_PLATFORM_FUCHSIA*/
-
-enum class MemoryOverallocationBehaviorAMD {
-  eDefault = VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD,
-  eAllowed = VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD,
-  eDisallowed = VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD
-};
-
-VULKAN_HPP_INLINE std::string to_string(MemoryOverallocationBehaviorAMD value) {
-  switch (value) {
-  case MemoryOverallocationBehaviorAMD::eDefault:
-    return "Default";
-  case MemoryOverallocationBehaviorAMD::eAllowed:
-    return "Allowed";
-  case MemoryOverallocationBehaviorAMD::eDisallowed:
-    return "Disallowed";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class MemoryPropertyFlagBits : VkMemoryPropertyFlags {
-  eDeviceLocal = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
-  eHostVisible = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
-  eHostCoherent = VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
-  eHostCached = VK_MEMORY_PROPERTY_HOST_CACHED_BIT,
-  eLazilyAllocated = VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT,
-  eProtected = VK_MEMORY_PROPERTY_PROTECTED_BIT,
-  eDeviceCoherentAMD = VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD,
-  eDeviceUncachedAMD = VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD
-};
-
-VULKAN_HPP_INLINE std::string to_string(MemoryPropertyFlagBits value) {
-  switch (value) {
-  case MemoryPropertyFlagBits::eDeviceLocal:
-    return "DeviceLocal";
-  case MemoryPropertyFlagBits::eHostVisible:
-    return "HostVisible";
-  case MemoryPropertyFlagBits::eHostCoherent:
-    return "HostCoherent";
-  case MemoryPropertyFlagBits::eHostCached:
-    return "HostCached";
-  case MemoryPropertyFlagBits::eLazilyAllocated:
-    return "LazilyAllocated";
-  case MemoryPropertyFlagBits::eProtected:
-    return "Protected";
-  case MemoryPropertyFlagBits::eDeviceCoherentAMD:
-    return "DeviceCoherentAMD";
-  case MemoryPropertyFlagBits::eDeviceUncachedAMD:
-    return "DeviceUncachedAMD";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class ObjectType {
-  // clang-format off
-      eUnknown = VK_OBJECT_TYPE_UNKNOWN
-    , eInstance = VK_OBJECT_TYPE_INSTANCE
-    , ePhysicalDevice = VK_OBJECT_TYPE_PHYSICAL_DEVICE
-    , eDevice = VK_OBJECT_TYPE_DEVICE
-    , eQueue = VK_OBJECT_TYPE_QUEUE
-    , eSemaphore = VK_OBJECT_TYPE_SEMAPHORE
-    , eCommandBuffer = VK_OBJECT_TYPE_COMMAND_BUFFER
-    , eFence = VK_OBJECT_TYPE_FENCE
-    , eDeviceMemory = VK_OBJECT_TYPE_DEVICE_MEMORY
-    , eBuffer = VK_OBJECT_TYPE_BUFFER
-    , eImage = VK_OBJECT_TYPE_IMAGE
-    , eEvent = VK_OBJECT_TYPE_EVENT
-    , eQueryPool = VK_OBJECT_TYPE_QUERY_POOL
-    , eBufferView = VK_OBJECT_TYPE_BUFFER_VIEW
-    , eImageView = VK_OBJECT_TYPE_IMAGE_VIEW
-    , eShaderModule = VK_OBJECT_TYPE_SHADER_MODULE
-    , ePipelineCache = VK_OBJECT_TYPE_PIPELINE_CACHE
-    , ePipelineLayout = VK_OBJECT_TYPE_PIPELINE_LAYOUT
-    , eRenderPass = VK_OBJECT_TYPE_RENDER_PASS
-    , ePipeline = VK_OBJECT_TYPE_PIPELINE
-    , eDescriptorSetLayout = VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT
-    , eSampler = VK_OBJECT_TYPE_SAMPLER
-    , eDescriptorPool = VK_OBJECT_TYPE_DESCRIPTOR_POOL
-    , eDescriptorSet = VK_OBJECT_TYPE_DESCRIPTOR_SET
-    , eFramebuffer = VK_OBJECT_TYPE_FRAMEBUFFER
-    , eCommandPool = VK_OBJECT_TYPE_COMMAND_POOL
-    , eSamplerYcbcrConversion = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION
-    , eDescriptorUpdateTemplate = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE
-    , eSurfaceKHR = VK_OBJECT_TYPE_SURFACE_KHR
-    , eSwapchainKHR = VK_OBJECT_TYPE_SWAPCHAIN_KHR
-    , eDisplayKHR = VK_OBJECT_TYPE_DISPLAY_KHR
-    , eDisplayModeKHR = VK_OBJECT_TYPE_DISPLAY_MODE_KHR
-    , eDebugReportCallbackEXT = VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT
-    , eDebugUtilsMessengerEXT = VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT
-    , eAccelerationStructureKHR = VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR
-    , eValidationCacheEXT = VK_OBJECT_TYPE_VALIDATION_CACHE_EXT
-    , eAccelerationStructureNV = VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV
-    , ePerformanceConfigurationINTEL = VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL
-    , eDeferredOperationKHR = VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR
-    , eIndirectCommandsLayoutNV = VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV
-    , ePrivateDataSlotEXT = VK_OBJECT_TYPE_PRIVATE_DATA_SLOT_EXT
-#if defined( VK_USE_PLATFORM_FUCHSIA )
-    , eBufferCollectionFUCHSIA = VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA
-#endif /*VK_USE_PLATFORM_FUCHSIA*/
-    , eDescriptorUpdateTemplateKHR = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR
-    , eSamplerYcbcrConversionKHR = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR
-  // clang-format on
-};
-
-VULKAN_HPP_INLINE std::string to_string(ObjectType value) {
-  switch (value) {
-  case ObjectType::eUnknown:
-    return "Unknown";
-  case ObjectType::eInstance:
-    return "Instance";
-  case ObjectType::ePhysicalDevice:
-    return "PhysicalDevice";
-  case ObjectType::eDevice:
-    return "Device";
-  case ObjectType::eQueue:
-    return "Queue";
-  case ObjectType::eSemaphore:
-    return "Semaphore";
-  case ObjectType::eCommandBuffer:
-    return "CommandBuffer";
-  case ObjectType::eFence:
-    return "Fence";
-  case ObjectType::eDeviceMemory:
-    return "DeviceMemory";
-  case ObjectType::eBuffer:
-    return "Buffer";
-  case ObjectType::eImage:
-    return "Image";
-  case ObjectType::eEvent:
-    return "Event";
-  case ObjectType::eQueryPool:
-    return "QueryPool";
-  case ObjectType::eBufferView:
-    return "BufferView";
-  case ObjectType::eImageView:
-    return "ImageView";
-  case ObjectType::eShaderModule:
-    return "ShaderModule";
-  case ObjectType::ePipelineCache:
-    return "PipelineCache";
-  case ObjectType::ePipelineLayout:
-    return "PipelineLayout";
-  case ObjectType::eRenderPass:
-    return "RenderPass";
-  case ObjectType::ePipeline:
-    return "Pipeline";
-  case ObjectType::eDescriptorSetLayout:
-    return "DescriptorSetLayout";
-  case ObjectType::eSampler:
-    return "Sampler";
-  case ObjectType::eDescriptorPool:
-    return "DescriptorPool";
-  case ObjectType::eDescriptorSet:
-    return "DescriptorSet";
-  case ObjectType::eFramebuffer:
-    return "Framebuffer";
-  case ObjectType::eCommandPool:
-    return "CommandPool";
-  case ObjectType::eSamplerYcbcrConversion:
-    return "SamplerYcbcrConversion";
-  case ObjectType::eDescriptorUpdateTemplate:
-    return "DescriptorUpdateTemplate";
-  case ObjectType::eSurfaceKHR:
-    return "SurfaceKHR";
-  case ObjectType::eSwapchainKHR:
-    return "SwapchainKHR";
-  case ObjectType::eDisplayKHR:
-    return "DisplayKHR";
-  case ObjectType::eDisplayModeKHR:
-    return "DisplayModeKHR";
-  case ObjectType::eDebugReportCallbackEXT:
-    return "DebugReportCallbackEXT";
-  case ObjectType::eDebugUtilsMessengerEXT:
-    return "DebugUtilsMessengerEXT";
-  case ObjectType::eAccelerationStructureKHR:
-    return "AccelerationStructureKHR";
-  case ObjectType::eValidationCacheEXT:
-    return "ValidationCacheEXT";
-  case ObjectType::eAccelerationStructureNV:
-    return "AccelerationStructureNV";
-  case ObjectType::ePerformanceConfigurationINTEL:
-    return "PerformanceConfigurationINTEL";
-  case ObjectType::eDeferredOperationKHR:
-    return "DeferredOperationKHR";
-  case ObjectType::eIndirectCommandsLayoutNV:
-    return "IndirectCommandsLayoutNV";
-  case ObjectType::ePrivateDataSlotEXT:
-    return "PrivateDataSlotEXT";
-#if defined(VK_USE_PLATFORM_FUCHSIA)
-  case ObjectType::eBufferCollectionFUCHSIA:
-    return "BufferCollectionFUCHSIA";
-#endif /*VK_USE_PLATFORM_FUCHSIA*/
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-template <ObjectType value> struct cpp_type {};
-
-enum class PeerMemoryFeatureFlagBits : VkPeerMemoryFeatureFlags {
-  eCopySrc = VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT,
-  eCopyDst = VK_PEER_MEMORY_FEATURE_COPY_DST_BIT,
-  eGenericSrc = VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT,
-  eGenericDst = VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT
-};
-using PeerMemoryFeatureFlagBitsKHR = PeerMemoryFeatureFlagBits;
-
-VULKAN_HPP_INLINE std::string to_string(PeerMemoryFeatureFlagBits value) {
-  switch (value) {
-  case PeerMemoryFeatureFlagBits::eCopySrc:
-    return "CopySrc";
-  case PeerMemoryFeatureFlagBits::eCopyDst:
-    return "CopyDst";
-  case PeerMemoryFeatureFlagBits::eGenericSrc:
-    return "GenericSrc";
-  case PeerMemoryFeatureFlagBits::eGenericDst:
-    return "GenericDst";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class PerformanceConfigurationTypeINTEL {
-  eCommandQueueMetricsDiscoveryActivated =
-      VK_PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL
-};
-
-VULKAN_HPP_INLINE std::string
-to_string(PerformanceConfigurationTypeINTEL value) {
-  switch (value) {
-  case PerformanceConfigurationTypeINTEL::
-      eCommandQueueMetricsDiscoveryActivated:
-    return "CommandQueueMetricsDiscoveryActivated";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class
-    PerformanceCounterDescriptionFlagBitsKHR : VkPerformanceCounterDescriptionFlagsKHR {
-      ePerformanceImpacting =
-          VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR,
-      eConcurrentlyImpacted =
-          VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR
-    };
-
-VULKAN_HPP_INLINE std::string
-to_string(PerformanceCounterDescriptionFlagBitsKHR value) {
-  switch (value) {
-  case PerformanceCounterDescriptionFlagBitsKHR::ePerformanceImpacting:
-    return "PerformanceImpacting";
-  case PerformanceCounterDescriptionFlagBitsKHR::eConcurrentlyImpacted:
-    return "ConcurrentlyImpacted";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class PerformanceCounterScopeKHR {
-  eCommandBuffer = VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR,
-  eRenderPass = VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR,
-  eCommand = VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR,
-  eVkQueryScopeCommandBuffer = VK_QUERY_SCOPE_COMMAND_BUFFER_KHR,
-  eVkQueryScopeCommand = VK_QUERY_SCOPE_COMMAND_KHR,
-  eVkQueryScopeRenderPass = VK_QUERY_SCOPE_RENDER_PASS_KHR
-};
-
-VULKAN_HPP_INLINE std::string to_string(PerformanceCounterScopeKHR value) {
-  switch (value) {
-  case PerformanceCounterScopeKHR::eCommandBuffer:
-    return "CommandBuffer";
-  case PerformanceCounterScopeKHR::eRenderPass:
-    return "RenderPass";
-  case PerformanceCounterScopeKHR::eCommand:
-    return "Command";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class PerformanceCounterStorageKHR {
-  eInt32 = VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR,
-  eInt64 = VK_PERFORMANCE_COUNTER_STORAGE_INT64_KHR,
-  eUint32 = VK_PERFORMANCE_COUNTER_STORAGE_UINT32_KHR,
-  eUint64 = VK_PERFORMANCE_COUNTER_STORAGE_UINT64_KHR,
-  eFloat32 = VK_PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR,
-  eFloat64 = VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR
-};
-
-VULKAN_HPP_INLINE std::string to_string(PerformanceCounterStorageKHR value) {
-  switch (value) {
-  case PerformanceCounterStorageKHR::eInt32:
-    return "Int32";
-  case PerformanceCounterStorageKHR::eInt64:
-    return "Int64";
-  case PerformanceCounterStorageKHR::eUint32:
-    return "Uint32";
-  case PerformanceCounterStorageKHR::eUint64:
-    return "Uint64";
-  case PerformanceCounterStorageKHR::eFloat32:
-    return "Float32";
-  case PerformanceCounterStorageKHR::eFloat64:
-    return "Float64";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class PerformanceCounterUnitKHR {
-  eGeneric = VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR,
-  ePercentage = VK_PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR,
-  eNanoseconds = VK_PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR,
-  eBytes = VK_PERFORMANCE_COUNTER_UNIT_BYTES_KHR,
-  eBytesPerSecond = VK_PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR,
-  eKelvin = VK_PERFORMANCE_COUNTER_UNIT_KELVIN_KHR,
-  eWatts = VK_PERFORMANCE_COUNTER_UNIT_WATTS_KHR,
-  eVolts = VK_PERFORMANCE_COUNTER_UNIT_VOLTS_KHR,
-  eAmps = VK_PERFORMANCE_COUNTER_UNIT_AMPS_KHR,
-  eHertz = VK_PERFORMANCE_COUNTER_UNIT_HERTZ_KHR,
-  eCycles = VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR
-};
-
-VULKAN_HPP_INLINE std::string to_string(PerformanceCounterUnitKHR value) {
-  switch (value) {
-  case PerformanceCounterUnitKHR::eGeneric:
-    return "Generic";
-  case PerformanceCounterUnitKHR::ePercentage:
-    return "Percentage";
-  case PerformanceCounterUnitKHR::eNanoseconds:
-    return "Nanoseconds";
-  case PerformanceCounterUnitKHR::eBytes:
-    return "Bytes";
-  case PerformanceCounterUnitKHR::eBytesPerSecond:
-    return "BytesPerSecond";
-  case PerformanceCounterUnitKHR::eKelvin:
-    return "Kelvin";
-  case PerformanceCounterUnitKHR::eWatts:
-    return "Watts";
-  case PerformanceCounterUnitKHR::eVolts:
-    return "Volts";
-  case PerformanceCounterUnitKHR::eAmps:
-    return "Amps";
-  case PerformanceCounterUnitKHR::eHertz:
-    return "Hertz";
-  case PerformanceCounterUnitKHR::eCycles:
-    return "Cycles";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class PerformanceOverrideTypeINTEL {
-  eNullHardware = VK_PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL,
-  eFlushGpuCaches = VK_PERFORMANCE_OVERRIDE_TYPE_FLUSH_GPU_CACHES_INTEL
-};
-
-VULKAN_HPP_INLINE std::string to_string(PerformanceOverrideTypeINTEL value) {
-  switch (value) {
-  case PerformanceOverrideTypeINTEL::eNullHardware:
-    return "NullHardware";
-  case PerformanceOverrideTypeINTEL::eFlushGpuCaches:
-    return "FlushGpuCaches";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class PerformanceParameterTypeINTEL {
-  eHwCountersSupported =
-      VK_PERFORMANCE_PARAMETER_TYPE_HW_COUNTERS_SUPPORTED_INTEL,
-  eStreamMarkerValidBits =
-      VK_PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL
-};
-
-VULKAN_HPP_INLINE std::string to_string(PerformanceParameterTypeINTEL value) {
-  switch (value) {
-  case PerformanceParameterTypeINTEL::eHwCountersSupported:
-    return "HwCountersSupported";
-  case PerformanceParameterTypeINTEL::eStreamMarkerValidBits:
-    return "StreamMarkerValidBits";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class PerformanceValueTypeINTEL {
-  eUint32 = VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL,
-  eUint64 = VK_PERFORMANCE_VALUE_TYPE_UINT64_INTEL,
-  eFloat = VK_PERFORMANCE_VALUE_TYPE_FLOAT_INTEL,
-  eBool = VK_PERFORMANCE_VALUE_TYPE_BOOL_INTEL,
-  eString = VK_PERFORMANCE_VALUE_TYPE_STRING_INTEL
-};
-
-VULKAN_HPP_INLINE std::string to_string(PerformanceValueTypeINTEL value) {
-  switch (value) {
-  case PerformanceValueTypeINTEL::eUint32:
-    return "Uint32";
-  case PerformanceValueTypeINTEL::eUint64:
-    return "Uint64";
-  case PerformanceValueTypeINTEL::eFloat:
-    return "Float";
-  case PerformanceValueTypeINTEL::eBool:
-    return "Bool";
-  case PerformanceValueTypeINTEL::eString:
-    return "String";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class PhysicalDeviceType {
-  eOther = VK_PHYSICAL_DEVICE_TYPE_OTHER,
-  eIntegratedGpu = VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU,
-  eDiscreteGpu = VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU,
-  eVirtualGpu = VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU,
-  eCpu = VK_PHYSICAL_DEVICE_TYPE_CPU
-};
-
-VULKAN_HPP_INLINE std::string to_string(PhysicalDeviceType value) {
-  switch (value) {
-  case PhysicalDeviceType::eOther:
-    return "Other";
-  case PhysicalDeviceType::eIntegratedGpu:
-    return "IntegratedGpu";
-  case PhysicalDeviceType::eDiscreteGpu:
-    return "DiscreteGpu";
-  case PhysicalDeviceType::eVirtualGpu:
-    return "VirtualGpu";
-  case PhysicalDeviceType::eCpu:
-    return "Cpu";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class PipelineBindPoint {
-  eGraphics = VK_PIPELINE_BIND_POINT_GRAPHICS,
-  eCompute = VK_PIPELINE_BIND_POINT_COMPUTE,
-  eRayTracingKHR = VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR,
-  eRayTracingNV = VK_PIPELINE_BIND_POINT_RAY_TRACING_NV
-};
-
-VULKAN_HPP_INLINE std::string to_string(PipelineBindPoint value) {
-  switch (value) {
-  case PipelineBindPoint::eGraphics:
-    return "Graphics";
-  case PipelineBindPoint::eCompute:
-    return "Compute";
-  case PipelineBindPoint::eRayTracingKHR:
-    return "RayTracingKHR";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class PipelineCacheCreateFlagBits : VkPipelineCacheCreateFlags {
-  eExternallySynchronizedEXT =
-      VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT
-};
-
-VULKAN_HPP_INLINE std::string to_string(PipelineCacheCreateFlagBits value) {
-  switch (value) {
-  case PipelineCacheCreateFlagBits::eExternallySynchronizedEXT:
-    return "ExternallySynchronizedEXT";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class PipelineCacheHeaderVersion {
-  eOne = VK_PIPELINE_CACHE_HEADER_VERSION_ONE
-};
-
-VULKAN_HPP_INLINE std::string to_string(PipelineCacheHeaderVersion value) {
-  switch (value) {
-  case PipelineCacheHeaderVersion::eOne:
-    return "One";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class
-    PipelineCompilerControlFlagBitsAMD : VkPipelineCompilerControlFlagsAMD {};
-
-VULKAN_HPP_INLINE std::string to_string(PipelineCompilerControlFlagBitsAMD) {
-  return "(void)";
-}
-
-enum class PipelineCreateFlagBits : VkPipelineCreateFlags {
-  eDisableOptimization = VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT,
-  eAllowDerivatives = VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT,
-  eDerivative = VK_PIPELINE_CREATE_DERIVATIVE_BIT,
-  eViewIndexFromDeviceIndex =
-      VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT,
-  eDispatchBase = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT,
-  eRayTracingNoNullAnyHitShadersKHR =
-      VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR,
-  eRayTracingNoNullClosestHitShadersKHR =
-      VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR,
-  eRayTracingNoNullMissShadersKHR =
-      VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR,
-  eRayTracingNoNullIntersectionShadersKHR =
-      VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR,
-  eRayTracingSkipTrianglesKHR =
-      VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR,
-  eRayTracingSkipAabbsKHR = VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR,
-  eRayTracingShaderGroupHandleCaptureReplayKHR =
-      VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR,
-  eDeferCompileNV = VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV,
-  eCaptureStatisticsKHR = VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR,
-  eCaptureInternalRepresentationsKHR =
-      VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR,
-  eIndirectBindableNV = VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV,
-  eLibraryKHR = VK_PIPELINE_CREATE_LIBRARY_BIT_KHR,
-  eFailOnPipelineCompileRequiredEXT =
-      VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_EXT,
-  eEarlyReturnOnFailureEXT = VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT_EXT,
-  eDispatchBaseKHR = VK_PIPELINE_CREATE_DISPATCH_BASE_KHR,
-  eViewIndexFromDeviceIndexKHR =
-      VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR
-};
-
-VULKAN_HPP_INLINE std::string to_string(PipelineCreateFlagBits value) {
-  switch (value) {
-  case PipelineCreateFlagBits::eDisableOptimization:
-    return "DisableOptimization";
-  case PipelineCreateFlagBits::eAllowDerivatives:
-    return "AllowDerivatives";
-  case PipelineCreateFlagBits::eDerivative:
-    return "Derivative";
-  case PipelineCreateFlagBits::eViewIndexFromDeviceIndex:
-    return "ViewIndexFromDeviceIndex";
-  case PipelineCreateFlagBits::eDispatchBase:
-    return "DispatchBase";
-  case PipelineCreateFlagBits::eRayTracingNoNullAnyHitShadersKHR:
-    return "RayTracingNoNullAnyHitShadersKHR";
-  case PipelineCreateFlagBits::eRayTracingNoNullClosestHitShadersKHR:
-    return "RayTracingNoNullClosestHitShadersKHR";
-  case PipelineCreateFlagBits::eRayTracingNoNullMissShadersKHR:
-    return "RayTracingNoNullMissShadersKHR";
-  case PipelineCreateFlagBits::eRayTracingNoNullIntersectionShadersKHR:
-    return "RayTracingNoNullIntersectionShadersKHR";
-  case PipelineCreateFlagBits::eRayTracingSkipTrianglesKHR:
-    return "RayTracingSkipTrianglesKHR";
-  case PipelineCreateFlagBits::eRayTracingSkipAabbsKHR:
-    return "RayTracingSkipAabbsKHR";
-  case PipelineCreateFlagBits::eRayTracingShaderGroupHandleCaptureReplayKHR:
-    return "RayTracingShaderGroupHandleCaptureReplayKHR";
-  case PipelineCreateFlagBits::eDeferCompileNV:
-    return "DeferCompileNV";
-  case PipelineCreateFlagBits::eCaptureStatisticsKHR:
-    return "CaptureStatisticsKHR";
-  case PipelineCreateFlagBits::eCaptureInternalRepresentationsKHR:
-    return "CaptureInternalRepresentationsKHR";
-  case PipelineCreateFlagBits::eIndirectBindableNV:
-    return "IndirectBindableNV";
-  case PipelineCreateFlagBits::eLibraryKHR:
-    return "LibraryKHR";
-  case PipelineCreateFlagBits::eFailOnPipelineCompileRequiredEXT:
-    return "FailOnPipelineCompileRequiredEXT";
-  case PipelineCreateFlagBits::eEarlyReturnOnFailureEXT:
-    return "EarlyReturnOnFailureEXT";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class
-    PipelineCreationFeedbackFlagBitsEXT : VkPipelineCreationFeedbackFlagsEXT {
-      eValid = VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT_EXT,
-      eApplicationPipelineCacheHit =
-          VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT_EXT,
-      eBasePipelineAcceleration =
-          VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT_EXT
-    };
-
-VULKAN_HPP_INLINE std::string
-to_string(PipelineCreationFeedbackFlagBitsEXT value) {
-  switch (value) {
-  case PipelineCreationFeedbackFlagBitsEXT::eValid:
-    return "Valid";
-  case PipelineCreationFeedbackFlagBitsEXT::eApplicationPipelineCacheHit:
-    return "ApplicationPipelineCacheHit";
-  case PipelineCreationFeedbackFlagBitsEXT::eBasePipelineAcceleration:
-    return "BasePipelineAcceleration";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class PipelineExecutableStatisticFormatKHR {
-  eBool32 = VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR,
-  eInt64 = VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR,
-  eUint64 = VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR,
-  eFloat64 = VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR
-};
-
-VULKAN_HPP_INLINE std::string
-to_string(PipelineExecutableStatisticFormatKHR value) {
-  switch (value) {
-  case PipelineExecutableStatisticFormatKHR::eBool32:
-    return "Bool32";
-  case PipelineExecutableStatisticFormatKHR::eInt64:
-    return "Int64";
-  case PipelineExecutableStatisticFormatKHR::eUint64:
-    return "Uint64";
-  case PipelineExecutableStatisticFormatKHR::eFloat64:
-    return "Float64";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class
-    PipelineShaderStageCreateFlagBits : VkPipelineShaderStageCreateFlags {
-      eAllowVaryingSubgroupSizeEXT =
-          VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT,
-      eRequireFullSubgroupsEXT =
-          VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT
-    };
-
-VULKAN_HPP_INLINE std::string
-to_string(PipelineShaderStageCreateFlagBits value) {
-  switch (value) {
-  case PipelineShaderStageCreateFlagBits::eAllowVaryingSubgroupSizeEXT:
-    return "AllowVaryingSubgroupSizeEXT";
-  case PipelineShaderStageCreateFlagBits::eRequireFullSubgroupsEXT:
-    return "RequireFullSubgroupsEXT";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class PipelineStageFlagBits : VkPipelineStageFlags {
-  eTopOfPipe = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
-  eDrawIndirect = VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT,
-  eVertexInput = VK_PIPELINE_STAGE_VERTEX_INPUT_BIT,
-  eVertexShader = VK_PIPELINE_STAGE_VERTEX_SHADER_BIT,
-  eTessellationControlShader =
-      VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT,
-  eTessellationEvaluationShader =
-      VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT,
-  eGeometryShader = VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT,
-  eFragmentShader = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
-  eEarlyFragmentTests = VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT,
-  eLateFragmentTests = VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
-  eColorAttachmentOutput = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
-  eComputeShader = VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
-  eTransfer = VK_PIPELINE_STAGE_TRANSFER_BIT,
-  eBottomOfPipe = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
-  eHost = VK_PIPELINE_STAGE_HOST_BIT,
-  eAllGraphics = VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT,
-  eAllCommands = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
-  eTransformFeedbackEXT = VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT,
-  eConditionalRenderingEXT = VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT,
-  eAccelerationStructureBuildKHR =
-      VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR,
-  eRayTracingShaderKHR = VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR,
-  eShadingRateImageNV = VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV,
-  eTaskShaderNV = VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV,
-  eMeshShaderNV = VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV,
-  eFragmentDensityProcessEXT =
-      VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT,
-  eCommandPreprocessNV = VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_NV,
-  eNoneKHR = VK_PIPELINE_STAGE_NONE_KHR,
-  eAccelerationStructureBuildNV =
-      VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_NV,
-  eFragmentShadingRateAttachmentKHR =
-      VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR,
-  eRayTracingShaderNV = VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_NV
-};
-
-VULKAN_HPP_INLINE std::string to_string(PipelineStageFlagBits value) {
-  switch (value) {
-  case PipelineStageFlagBits::eTopOfPipe:
-    return "TopOfPipe";
-  case PipelineStageFlagBits::eDrawIndirect:
-    return "DrawIndirect";
-  case PipelineStageFlagBits::eVertexInput:
-    return "VertexInput";
-  case PipelineStageFlagBits::eVertexShader:
-    return "VertexShader";
-  case PipelineStageFlagBits::eTessellationControlShader:
-    return "TessellationControlShader";
-  case PipelineStageFlagBits::eTessellationEvaluationShader:
-    return "TessellationEvaluationShader";
-  case PipelineStageFlagBits::eGeometryShader:
-    return "GeometryShader";
-  case PipelineStageFlagBits::eFragmentShader:
-    return "FragmentShader";
-  case PipelineStageFlagBits::eEarlyFragmentTests:
-    return "EarlyFragmentTests";
-  case PipelineStageFlagBits::eLateFragmentTests:
-    return "LateFragmentTests";
-  case PipelineStageFlagBits::eColorAttachmentOutput:
-    return "ColorAttachmentOutput";
-  case PipelineStageFlagBits::eComputeShader:
-    return "ComputeShader";
-  case PipelineStageFlagBits::eTransfer:
-    return "Transfer";
-  case PipelineStageFlagBits::eBottomOfPipe:
-    return "BottomOfPipe";
-  case PipelineStageFlagBits::eHost:
-    return "Host";
-  case PipelineStageFlagBits::eAllGraphics:
-    return "AllGraphics";
-  case PipelineStageFlagBits::eAllCommands:
-    return "AllCommands";
-  case PipelineStageFlagBits::eTransformFeedbackEXT:
-    return "TransformFeedbackEXT";
-  case PipelineStageFlagBits::eConditionalRenderingEXT:
-    return "ConditionalRenderingEXT";
-  case PipelineStageFlagBits::eAccelerationStructureBuildKHR:
-    return "AccelerationStructureBuildKHR";
-  case PipelineStageFlagBits::eRayTracingShaderKHR:
-    return "RayTracingShaderKHR";
-  case PipelineStageFlagBits::eShadingRateImageNV:
-    return "ShadingRateImageNV";
-  case PipelineStageFlagBits::eTaskShaderNV:
-    return "TaskShaderNV";
-  case PipelineStageFlagBits::eMeshShaderNV:
-    return "MeshShaderNV";
-  case PipelineStageFlagBits::eFragmentDensityProcessEXT:
-    return "FragmentDensityProcessEXT";
-  case PipelineStageFlagBits::eCommandPreprocessNV:
-    return "CommandPreprocessNV";
-  case PipelineStageFlagBits::eNoneKHR:
-    return "NoneKHR";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class PipelineStageFlagBits2KHR : VkPipelineStageFlags2KHR {
-  eNone = VK_PIPELINE_STAGE_2_NONE_KHR,
-  eTopOfPipe = VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT_KHR,
-  eDrawIndirect = VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT_KHR,
-  eVertexInput = VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT_KHR,
-  eVertexShader = VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT_KHR,
-  eTessellationControlShader =
-      VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT_KHR,
-  eTessellationEvaluationShader =
-      VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT_KHR,
-  eGeometryShader = VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT_KHR,
-  eFragmentShader = VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT_KHR,
-  eEarlyFragmentTests = VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT_KHR,
-  eLateFragmentTests = VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT_KHR,
-  eColorAttachmentOutput = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR,
-  eComputeShader = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT_KHR,
-  eAllTransfer = VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR,
-  eBottomOfPipe = VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT_KHR,
-  eHost = VK_PIPELINE_STAGE_2_HOST_BIT_KHR,
-  eAllGraphics = VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR,
-  eAllCommands = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR,
-  eCopy = VK_PIPELINE_STAGE_2_COPY_BIT_KHR,
-  eResolve = VK_PIPELINE_STAGE_2_RESOLVE_BIT_KHR,
-  eBlit = VK_PIPELINE_STAGE_2_BLIT_BIT_KHR,
-  eClear = VK_PIPELINE_STAGE_2_CLEAR_BIT_KHR,
-  eIndexInput = VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT_KHR,
-  eVertexAttributeInput = VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT_KHR,
-  ePreRasterizationShaders =
-      VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT_KHR,
-  eTransformFeedbackExt = VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT,
-  eConditionalRenderingExt = VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT,
-  eCommandPreprocessNv = VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV,
-  eFragmentShadingRateAttachment =
-      VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR,
-  eAccelerationStructureBuild =
-      VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR,
-  eRayTracingShader = VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR,
-  eFragmentDensityProcessExt =
-      VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT,
-  eTaskShaderNv = VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV,
-  eMeshShaderNv = VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV,
-  eAccelerationStructureBuildNv =
-      VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_NV,
-  eRayTracingShaderNv = VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_NV,
-  eShadingRateImageNv = VK_PIPELINE_STAGE_2_SHADING_RATE_IMAGE_BIT_NV,
-  eTransfer = VK_PIPELINE_STAGE_2_TRANSFER_BIT_KHR
-};
-
-VULKAN_HPP_INLINE std::string to_string(PipelineStageFlagBits2KHR value) {
-  switch (value) {
-  case PipelineStageFlagBits2KHR::eNone:
-    return "None";
-  case PipelineStageFlagBits2KHR::eTopOfPipe:
-    return "TopOfPipe";
-  case PipelineStageFlagBits2KHR::eDrawIndirect:
-    return "DrawIndirect";
-  case PipelineStageFlagBits2KHR::eVertexInput:
-    return "VertexInput";
-  case PipelineStageFlagBits2KHR::eVertexShader:
-    return "VertexShader";
-  case PipelineStageFlagBits2KHR::eTessellationControlShader:
-    return "TessellationControlShader";
-  case PipelineStageFlagBits2KHR::eTessellationEvaluationShader:
-    return "TessellationEvaluationShader";
-  case PipelineStageFlagBits2KHR::eGeometryShader:
-    return "GeometryShader";
-  case PipelineStageFlagBits2KHR::eFragmentShader:
-    return "FragmentShader";
-  case PipelineStageFlagBits2KHR::eEarlyFragmentTests:
-    return "EarlyFragmentTests";
-  case PipelineStageFlagBits2KHR::eLateFragmentTests:
-    return "LateFragmentTests";
-  case PipelineStageFlagBits2KHR::eColorAttachmentOutput:
-    return "ColorAttachmentOutput";
-  case PipelineStageFlagBits2KHR::eComputeShader:
-    return "ComputeShader";
-  case PipelineStageFlagBits2KHR::eAllTransfer:
-    return "AllTransfer";
-  case PipelineStageFlagBits2KHR::eBottomOfPipe:
-    return "BottomOfPipe";
-  case PipelineStageFlagBits2KHR::eHost:
-    return "Host";
-  case PipelineStageFlagBits2KHR::eAllGraphics:
-    return "AllGraphics";
-  case PipelineStageFlagBits2KHR::eAllCommands:
-    return "AllCommands";
-  case PipelineStageFlagBits2KHR::eCopy:
-    return "Copy";
-  case PipelineStageFlagBits2KHR::eResolve:
-    return "Resolve";
-  case PipelineStageFlagBits2KHR::eBlit:
-    return "Blit";
-  case PipelineStageFlagBits2KHR::eClear:
-    return "Clear";
-  case PipelineStageFlagBits2KHR::eIndexInput:
-    return "IndexInput";
-  case PipelineStageFlagBits2KHR::eVertexAttributeInput:
-    return "VertexAttributeInput";
-  case PipelineStageFlagBits2KHR::ePreRasterizationShaders:
-    return "PreRasterizationShaders";
-  case PipelineStageFlagBits2KHR::eTransformFeedbackExt:
-    return "TransformFeedbackExt";
-  case PipelineStageFlagBits2KHR::eConditionalRenderingExt:
-    return "ConditionalRenderingExt";
-  case PipelineStageFlagBits2KHR::eCommandPreprocessNv:
-    return "CommandPreprocessNv";
-  case PipelineStageFlagBits2KHR::eFragmentShadingRateAttachment:
-    return "FragmentShadingRateAttachment";
-  case PipelineStageFlagBits2KHR::eAccelerationStructureBuild:
-    return "AccelerationStructureBuild";
-  case PipelineStageFlagBits2KHR::eRayTracingShader:
-    return "RayTracingShader";
-  case PipelineStageFlagBits2KHR::eFragmentDensityProcessExt:
-    return "FragmentDensityProcessExt";
-  case PipelineStageFlagBits2KHR::eTaskShaderNv:
-    return "TaskShaderNv";
-  case PipelineStageFlagBits2KHR::eMeshShaderNv:
-    return "MeshShaderNv";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class PointClippingBehavior {
-  eAllClipPlanes = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES,
-  eUserClipPlanesOnly = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY
-};
-using PointClippingBehaviorKHR = PointClippingBehavior;
-
-VULKAN_HPP_INLINE std::string to_string(PointClippingBehavior value) {
-  switch (value) {
-  case PointClippingBehavior::eAllClipPlanes:
-    return "AllClipPlanes";
-  case PointClippingBehavior::eUserClipPlanesOnly:
-    return "UserClipPlanesOnly";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class PolygonMode {
-  eFill = VK_POLYGON_MODE_FILL,
-  eLine = VK_POLYGON_MODE_LINE,
-  ePoint = VK_POLYGON_MODE_POINT,
-  eFillRectangleNV = VK_POLYGON_MODE_FILL_RECTANGLE_NV
-};
-
-VULKAN_HPP_INLINE std::string to_string(PolygonMode value) {
-  switch (value) {
-  case PolygonMode::eFill:
-    return "Fill";
-  case PolygonMode::eLine:
-    return "Line";
-  case PolygonMode::ePoint:
-    return "Point";
-  case PolygonMode::eFillRectangleNV:
-    return "FillRectangleNV";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class PresentModeKHR {
-  eImmediate = VK_PRESENT_MODE_IMMEDIATE_KHR,
-  eMailbox = VK_PRESENT_MODE_MAILBOX_KHR,
-  eFifo = VK_PRESENT_MODE_FIFO_KHR,
-  eFifoRelaxed = VK_PRESENT_MODE_FIFO_RELAXED_KHR,
-  eSharedDemandRefresh = VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR,
-  eSharedContinuousRefresh = VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR
-};
-
-VULKAN_HPP_INLINE std::string to_string(PresentModeKHR value) {
-  switch (value) {
-  case PresentModeKHR::eImmediate:
-    return "Immediate";
-  case PresentModeKHR::eMailbox:
-    return "Mailbox";
-  case PresentModeKHR::eFifo:
-    return "Fifo";
-  case PresentModeKHR::eFifoRelaxed:
-    return "FifoRelaxed";
-  case PresentModeKHR::eSharedDemandRefresh:
-    return "SharedDemandRefresh";
-  case PresentModeKHR::eSharedContinuousRefresh:
-    return "SharedContinuousRefresh";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class PrimitiveTopology {
-  ePointList = VK_PRIMITIVE_TOPOLOGY_POINT_LIST,
-  eLineList = VK_PRIMITIVE_TOPOLOGY_LINE_LIST,
-  eLineStrip = VK_PRIMITIVE_TOPOLOGY_LINE_STRIP,
-  eTriangleList = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
-  eTriangleStrip = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP,
-  eTriangleFan = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN,
-  eLineListWithAdjacency = VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY,
-  eLineStripWithAdjacency = VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY,
-  eTriangleListWithAdjacency =
-      VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY,
-  eTriangleStripWithAdjacency =
-      VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY,
-  ePatchList = VK_PRIMITIVE_TOPOLOGY_PATCH_LIST
-};
-
-VULKAN_HPP_INLINE std::string to_string(PrimitiveTopology value) {
-  switch (value) {
-  case PrimitiveTopology::ePointList:
-    return "PointList";
-  case PrimitiveTopology::eLineList:
-    return "LineList";
-  case PrimitiveTopology::eLineStrip:
-    return "LineStrip";
-  case PrimitiveTopology::eTriangleList:
-    return "TriangleList";
-  case PrimitiveTopology::eTriangleStrip:
-    return "TriangleStrip";
-  case PrimitiveTopology::eTriangleFan:
-    return "TriangleFan";
-  case PrimitiveTopology::eLineListWithAdjacency:
-    return "LineListWithAdjacency";
-  case PrimitiveTopology::eLineStripWithAdjacency:
-    return "LineStripWithAdjacency";
-  case PrimitiveTopology::eTriangleListWithAdjacency:
-    return "TriangleListWithAdjacency";
-  case PrimitiveTopology::eTriangleStripWithAdjacency:
-    return "TriangleStripWithAdjacency";
-  case PrimitiveTopology::ePatchList:
-    return "PatchList";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class PrivateDataSlotCreateFlagBitsEXT : VkPrivateDataSlotCreateFlagsEXT {
-};
-
-VULKAN_HPP_INLINE std::string to_string(PrivateDataSlotCreateFlagBitsEXT) {
-  return "(void)";
-}
-
-enum class QueryControlFlagBits : VkQueryControlFlags {
-  ePrecise = VK_QUERY_CONTROL_PRECISE_BIT
-};
-
-VULKAN_HPP_INLINE std::string to_string(QueryControlFlagBits value) {
-  switch (value) {
-  case QueryControlFlagBits::ePrecise:
-    return "Precise";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class QueryPipelineStatisticFlagBits : VkQueryPipelineStatisticFlags {
-  eInputAssemblyVertices =
-      VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT,
-  eInputAssemblyPrimitives =
-      VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT,
-  eVertexShaderInvocations =
-      VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT,
-  eGeometryShaderInvocations =
-      VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT,
-  eGeometryShaderPrimitives =
-      VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT,
-  eClippingInvocations = VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT,
-  eClippingPrimitives = VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT,
-  eFragmentShaderInvocations =
-      VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT,
-  eTessellationControlShaderPatches =
-      VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT,
-  eTessellationEvaluationShaderInvocations =
-      VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT,
-  eComputeShaderInvocations =
-      VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT
-};
-
-VULKAN_HPP_INLINE std::string to_string(QueryPipelineStatisticFlagBits value) {
-  switch (value) {
-  case QueryPipelineStatisticFlagBits::eInputAssemblyVertices:
-    return "InputAssemblyVertices";
-  case QueryPipelineStatisticFlagBits::eInputAssemblyPrimitives:
-    return "InputAssemblyPrimitives";
-  case QueryPipelineStatisticFlagBits::eVertexShaderInvocations:
-    return "VertexShaderInvocations";
-  case QueryPipelineStatisticFlagBits::eGeometryShaderInvocations:
-    return "GeometryShaderInvocations";
-  case QueryPipelineStatisticFlagBits::eGeometryShaderPrimitives:
-    return "GeometryShaderPrimitives";
-  case QueryPipelineStatisticFlagBits::eClippingInvocations:
-    return "ClippingInvocations";
-  case QueryPipelineStatisticFlagBits::eClippingPrimitives:
-    return "ClippingPrimitives";
-  case QueryPipelineStatisticFlagBits::eFragmentShaderInvocations:
-    return "FragmentShaderInvocations";
-  case QueryPipelineStatisticFlagBits::eTessellationControlShaderPatches:
-    return "TessellationControlShaderPatches";
-  case QueryPipelineStatisticFlagBits::eTessellationEvaluationShaderInvocations:
-    return "TessellationEvaluationShaderInvocations";
-  case QueryPipelineStatisticFlagBits::eComputeShaderInvocations:
-    return "ComputeShaderInvocations";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class QueryPoolCreateFlagBits {};
-
-VULKAN_HPP_INLINE std::string to_string(QueryPoolCreateFlagBits) {
-  return "(void)";
-}
-
-enum class QueryPoolSamplingModeINTEL {
-  eManual = VK_QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL
-};
-
-VULKAN_HPP_INLINE std::string to_string(QueryPoolSamplingModeINTEL value) {
-  switch (value) {
-  case QueryPoolSamplingModeINTEL::eManual:
-    return "Manual";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class QueryResultFlagBits : VkQueryResultFlags {
-  e64 = VK_QUERY_RESULT_64_BIT,
-  eWait = VK_QUERY_RESULT_WAIT_BIT,
-  eWithAvailability = VK_QUERY_RESULT_WITH_AVAILABILITY_BIT,
-  ePartial = VK_QUERY_RESULT_PARTIAL_BIT
-};
-
-VULKAN_HPP_INLINE std::string to_string(QueryResultFlagBits value) {
-  switch (value) {
-  case QueryResultFlagBits::e64:
-    return "64";
-  case QueryResultFlagBits::eWait:
-    return "Wait";
-  case QueryResultFlagBits::eWithAvailability:
-    return "WithAvailability";
-  case QueryResultFlagBits::ePartial:
-    return "Partial";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class QueryType {
-  eOcclusion = VK_QUERY_TYPE_OCCLUSION,
-  ePipelineStatistics = VK_QUERY_TYPE_PIPELINE_STATISTICS,
-  eTimestamp = VK_QUERY_TYPE_TIMESTAMP,
-  eTransformFeedbackStreamEXT = VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT,
-  ePerformanceQueryKHR = VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR,
-  eAccelerationStructureCompactedSizeKHR =
-      VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR,
-  eAccelerationStructureSerializationSizeKHR =
-      VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR,
-  eAccelerationStructureCompactedSizeNV =
-      VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV,
-  ePerformanceQueryINTEL = VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL
-};
-
-VULKAN_HPP_INLINE std::string to_string(QueryType value) {
-  switch (value) {
-  case QueryType::eOcclusion:
-    return "Occlusion";
-  case QueryType::ePipelineStatistics:
-    return "PipelineStatistics";
-  case QueryType::eTimestamp:
-    return "Timestamp";
-  case QueryType::eTransformFeedbackStreamEXT:
-    return "TransformFeedbackStreamEXT";
-  case QueryType::ePerformanceQueryKHR:
-    return "PerformanceQueryKHR";
-  case QueryType::eAccelerationStructureCompactedSizeKHR:
-    return "AccelerationStructureCompactedSizeKHR";
-  case QueryType::eAccelerationStructureSerializationSizeKHR:
-    return "AccelerationStructureSerializationSizeKHR";
-  case QueryType::eAccelerationStructureCompactedSizeNV:
-    return "AccelerationStructureCompactedSizeNV";
-  case QueryType::ePerformanceQueryINTEL:
-    return "PerformanceQueryINTEL";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class QueueFlagBits : VkQueueFlags {
-  eGraphics = VK_QUEUE_GRAPHICS_BIT,
-  eCompute = VK_QUEUE_COMPUTE_BIT,
-  eTransfer = VK_QUEUE_TRANSFER_BIT,
-  eSparseBinding = VK_QUEUE_SPARSE_BINDING_BIT,
-  eProtected = VK_QUEUE_PROTECTED_BIT
-};
-
-VULKAN_HPP_INLINE std::string to_string(QueueFlagBits value) {
-  switch (value) {
-  case QueueFlagBits::eGraphics:
-    return "Graphics";
-  case QueueFlagBits::eCompute:
-    return "Compute";
-  case QueueFlagBits::eTransfer:
-    return "Transfer";
-  case QueueFlagBits::eSparseBinding:
-    return "SparseBinding";
-  case QueueFlagBits::eProtected:
-    return "Protected";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class QueueGlobalPriorityEXT {
-  eLow = VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT,
-  eMedium = VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT,
-  eHigh = VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT,
-  eRealtime = VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT
-};
-
-VULKAN_HPP_INLINE std::string to_string(QueueGlobalPriorityEXT value) {
-  switch (value) {
-  case QueueGlobalPriorityEXT::eLow:
-    return "Low";
-  case QueueGlobalPriorityEXT::eMedium:
-    return "Medium";
-  case QueueGlobalPriorityEXT::eHigh:
-    return "High";
-  case QueueGlobalPriorityEXT::eRealtime:
-    return "Realtime";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class RasterizationOrderAMD {
-  eStrict = VK_RASTERIZATION_ORDER_STRICT_AMD,
-  eRelaxed = VK_RASTERIZATION_ORDER_RELAXED_AMD
-};
-
-VULKAN_HPP_INLINE std::string to_string(RasterizationOrderAMD value) {
-  switch (value) {
-  case RasterizationOrderAMD::eStrict:
-    return "Strict";
-  case RasterizationOrderAMD::eRelaxed:
-    return "Relaxed";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class RayTracingShaderGroupTypeKHR {
-  eGeneral = VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR,
-  eTrianglesHitGroup = VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR,
-  eProceduralHitGroup =
-      VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR
-};
-using RayTracingShaderGroupTypeNV = RayTracingShaderGroupTypeKHR;
-
-VULKAN_HPP_INLINE std::string to_string(RayTracingShaderGroupTypeKHR value) {
-  switch (value) {
-  case RayTracingShaderGroupTypeKHR::eGeneral:
-    return "General";
-  case RayTracingShaderGroupTypeKHR::eTrianglesHitGroup:
-    return "TrianglesHitGroup";
-  case RayTracingShaderGroupTypeKHR::eProceduralHitGroup:
-    return "ProceduralHitGroup";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class RenderPassCreateFlagBits : VkRenderPassCreateFlags {
-  eTransformQCOM = VK_RENDER_PASS_CREATE_TRANSFORM_BIT_QCOM
-};
-
-VULKAN_HPP_INLINE std::string to_string(RenderPassCreateFlagBits value) {
-  switch (value) {
-  case RenderPassCreateFlagBits::eTransformQCOM:
-    return "TransformQCOM";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class ResolveModeFlagBits : VkResolveModeFlags {
-  eNone = VK_RESOLVE_MODE_NONE,
-  eSampleZero = VK_RESOLVE_MODE_SAMPLE_ZERO_BIT,
-  eAverage = VK_RESOLVE_MODE_AVERAGE_BIT,
-  eMin = VK_RESOLVE_MODE_MIN_BIT,
-  eMax = VK_RESOLVE_MODE_MAX_BIT
-};
-using ResolveModeFlagBitsKHR = ResolveModeFlagBits;
-
-VULKAN_HPP_INLINE std::string to_string(ResolveModeFlagBits value) {
-  switch (value) {
-  case ResolveModeFlagBits::eNone:
-    return "None";
-  case ResolveModeFlagBits::eSampleZero:
-    return "SampleZero";
-  case ResolveModeFlagBits::eAverage:
-    return "Average";
-  case ResolveModeFlagBits::eMin:
-    return "Min";
-  case ResolveModeFlagBits::eMax:
-    return "Max";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
+//=== VK_VERSION_1_0 ===
 
 enum class Result {
-  // clang-format off
-      eSuccess = VK_SUCCESS
-    , eNotReady = VK_NOT_READY
-    , eTimeout = VK_TIMEOUT
-    , eEventSet = VK_EVENT_SET
-    , eEventReset = VK_EVENT_RESET
-    , eIncomplete = VK_INCOMPLETE
-    , eErrorOutOfHostMemory = VK_ERROR_OUT_OF_HOST_MEMORY
-    , eErrorOutOfDeviceMemory = VK_ERROR_OUT_OF_DEVICE_MEMORY
-    , eErrorInitializationFailed = VK_ERROR_INITIALIZATION_FAILED
-    , eErrorDeviceLost = VK_ERROR_DEVICE_LOST
-    , eErrorMemoryMapFailed = VK_ERROR_MEMORY_MAP_FAILED
-    , eErrorLayerNotPresent = VK_ERROR_LAYER_NOT_PRESENT
-    , eErrorExtensionNotPresent = VK_ERROR_EXTENSION_NOT_PRESENT
-    , eErrorFeatureNotPresent = VK_ERROR_FEATURE_NOT_PRESENT
-    , eErrorIncompatibleDriver = VK_ERROR_INCOMPATIBLE_DRIVER
-    , eErrorTooManyObjects = VK_ERROR_TOO_MANY_OBJECTS
-    , eErrorFormatNotSupported = VK_ERROR_FORMAT_NOT_SUPPORTED
-    , eErrorFragmentedPool = VK_ERROR_FRAGMENTED_POOL
-    , eErrorUnknown = VK_ERROR_UNKNOWN
-    , eErrorOutOfPoolMemory = VK_ERROR_OUT_OF_POOL_MEMORY
-    , eErrorInvalidExternalHandle = VK_ERROR_INVALID_EXTERNAL_HANDLE
-    , eErrorFragmentation = VK_ERROR_FRAGMENTATION
-    , eErrorInvalidOpaqueCaptureAddress = VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS
-    , eErrorSurfaceLostKHR = VK_ERROR_SURFACE_LOST_KHR
-    , eErrorNativeWindowInUseKHR = VK_ERROR_NATIVE_WINDOW_IN_USE_KHR
-    , eSuboptimalKHR = VK_SUBOPTIMAL_KHR
-    , eErrorOutOfDateKHR = VK_ERROR_OUT_OF_DATE_KHR
-    , eErrorIncompatibleDisplayKHR = VK_ERROR_INCOMPATIBLE_DISPLAY_KHR
-    , eErrorValidationFailedEXT = VK_ERROR_VALIDATION_FAILED_EXT
-    , eErrorInvalidShaderNV = VK_ERROR_INVALID_SHADER_NV
-    , eErrorInvalidDrmFormatModifierPlaneLayoutEXT = VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT
-    , eErrorNotPermittedEXT = VK_ERROR_NOT_PERMITTED_EXT
-#if defined( VK_USE_PLATFORM_WIN32_KHR )
-    , eErrorFullScreenExclusiveModeLostEXT = VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT
+  eSuccess = VK_SUCCESS,
+  eNotReady = VK_NOT_READY,
+  eTimeout = VK_TIMEOUT,
+  eEventSet = VK_EVENT_SET,
+  eEventReset = VK_EVENT_RESET,
+  eIncomplete = VK_INCOMPLETE,
+  eErrorOutOfHostMemory = VK_ERROR_OUT_OF_HOST_MEMORY,
+  eErrorOutOfDeviceMemory = VK_ERROR_OUT_OF_DEVICE_MEMORY,
+  eErrorInitializationFailed = VK_ERROR_INITIALIZATION_FAILED,
+  eErrorDeviceLost = VK_ERROR_DEVICE_LOST,
+  eErrorMemoryMapFailed = VK_ERROR_MEMORY_MAP_FAILED,
+  eErrorLayerNotPresent = VK_ERROR_LAYER_NOT_PRESENT,
+  eErrorExtensionNotPresent = VK_ERROR_EXTENSION_NOT_PRESENT,
+  eErrorFeatureNotPresent = VK_ERROR_FEATURE_NOT_PRESENT,
+  eErrorIncompatibleDriver = VK_ERROR_INCOMPATIBLE_DRIVER,
+  eErrorTooManyObjects = VK_ERROR_TOO_MANY_OBJECTS,
+  eErrorFormatNotSupported = VK_ERROR_FORMAT_NOT_SUPPORTED,
+  eErrorFragmentedPool = VK_ERROR_FRAGMENTED_POOL,
+  eErrorUnknown = VK_ERROR_UNKNOWN,
+  eErrorOutOfPoolMemory = VK_ERROR_OUT_OF_POOL_MEMORY,
+  eErrorInvalidExternalHandle = VK_ERROR_INVALID_EXTERNAL_HANDLE,
+  eErrorFragmentation = VK_ERROR_FRAGMENTATION,
+  eErrorInvalidOpaqueCaptureAddress = VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS,
+  eErrorSurfaceLostKHR = VK_ERROR_SURFACE_LOST_KHR,
+  eErrorNativeWindowInUseKHR = VK_ERROR_NATIVE_WINDOW_IN_USE_KHR,
+  eSuboptimalKHR = VK_SUBOPTIMAL_KHR,
+  eErrorOutOfDateKHR = VK_ERROR_OUT_OF_DATE_KHR,
+  eErrorIncompatibleDisplayKHR = VK_ERROR_INCOMPATIBLE_DISPLAY_KHR,
+  eErrorValidationFailedEXT = VK_ERROR_VALIDATION_FAILED_EXT,
+  eErrorInvalidShaderNV = VK_ERROR_INVALID_SHADER_NV,
+  eErrorInvalidDrmFormatModifierPlaneLayoutEXT =
+      VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT,
+  eErrorNotPermittedEXT = VK_ERROR_NOT_PERMITTED_EXT,
+#if defined(VK_USE_PLATFORM_WIN32_KHR)
+  eErrorFullScreenExclusiveModeLostEXT =
+      VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT,
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
-    , eThreadIdleKHR = VK_THREAD_IDLE_KHR
-    , eThreadDoneKHR = VK_THREAD_DONE_KHR
-    , eOperationDeferredKHR = VK_OPERATION_DEFERRED_KHR
-    , eOperationNotDeferredKHR = VK_OPERATION_NOT_DEFERRED_KHR
-    , ePipelineCompileRequiredEXT = VK_PIPELINE_COMPILE_REQUIRED_EXT
-#if defined( VK_USE_PLATFORM_FUCHSIA )
-    , eErrorMemoryPinnedFUCHSIA = VK_ERROR_MEMORY_PINNED_FUCHSIA
+  eThreadIdleKHR = VK_THREAD_IDLE_KHR,
+  eThreadDoneKHR = VK_THREAD_DONE_KHR,
+  eOperationDeferredKHR = VK_OPERATION_DEFERRED_KHR,
+  eOperationNotDeferredKHR = VK_OPERATION_NOT_DEFERRED_KHR,
+  ePipelineCompileRequiredEXT = VK_PIPELINE_COMPILE_REQUIRED_EXT,
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+  eErrorMemoryPinnedFUCHSIA = VK_ERROR_MEMORY_PINNED_FUCHSIA,
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
-    , eErrorFragmentationEXT = VK_ERROR_FRAGMENTATION_EXT
-    , eErrorInvalidDeviceAddressEXT = VK_ERROR_INVALID_DEVICE_ADDRESS_EXT
-    , eErrorInvalidExternalHandleKHR = VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR
-    , eErrorInvalidOpaqueCaptureAddressKHR = VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR
-    , eErrorOutOfPoolMemoryKHR = VK_ERROR_OUT_OF_POOL_MEMORY_KHR
-    , eErrorPipelineCompileRequiredEXT = VK_ERROR_PIPELINE_COMPILE_REQUIRED_EXT
-  // clang-format on
+  eErrorFragmentationEXT = VK_ERROR_FRAGMENTATION_EXT,
+  eErrorInvalidDeviceAddressEXT = VK_ERROR_INVALID_DEVICE_ADDRESS_EXT,
+  eErrorInvalidExternalHandleKHR = VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR,
+  eErrorInvalidOpaqueCaptureAddressKHR =
+      VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR,
+  eErrorOutOfPoolMemoryKHR = VK_ERROR_OUT_OF_POOL_MEMORY_KHR,
+  eErrorPipelineCompileRequiredEXT = VK_ERROR_PIPELINE_COMPILE_REQUIRED_EXT
 };
 
 VULKAN_HPP_INLINE std::string to_string(Result value) {
@@ -10636,1231 +5377,1145 @@
   }
 }
 
-enum class SampleCountFlagBits : VkSampleCountFlags {
-  e1 = VK_SAMPLE_COUNT_1_BIT,
-  e2 = VK_SAMPLE_COUNT_2_BIT,
-  e4 = VK_SAMPLE_COUNT_4_BIT,
-  e8 = VK_SAMPLE_COUNT_8_BIT,
-  e16 = VK_SAMPLE_COUNT_16_BIT,
-  e32 = VK_SAMPLE_COUNT_32_BIT,
-  e64 = VK_SAMPLE_COUNT_64_BIT
-};
-
-VULKAN_HPP_INLINE std::string to_string(SampleCountFlagBits value) {
-  switch (value) {
-  case SampleCountFlagBits::e1:
-    return "1";
-  case SampleCountFlagBits::e2:
-    return "2";
-  case SampleCountFlagBits::e4:
-    return "4";
-  case SampleCountFlagBits::e8:
-    return "8";
-  case SampleCountFlagBits::e16:
-    return "16";
-  case SampleCountFlagBits::e32:
-    return "32";
-  case SampleCountFlagBits::e64:
-    return "64";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class SamplerAddressMode {
-  eRepeat = VK_SAMPLER_ADDRESS_MODE_REPEAT,
-  eMirroredRepeat = VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT,
-  eClampToEdge = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
-  eClampToBorder = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER,
-  eMirrorClampToEdge = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE,
-  eMirrorClampToEdgeKHR = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE_KHR
-};
-
-VULKAN_HPP_INLINE std::string to_string(SamplerAddressMode value) {
-  switch (value) {
-  case SamplerAddressMode::eRepeat:
-    return "Repeat";
-  case SamplerAddressMode::eMirroredRepeat:
-    return "MirroredRepeat";
-  case SamplerAddressMode::eClampToEdge:
-    return "ClampToEdge";
-  case SamplerAddressMode::eClampToBorder:
-    return "ClampToBorder";
-  case SamplerAddressMode::eMirrorClampToEdge:
-    return "MirrorClampToEdge";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class SamplerCreateFlagBits : VkSamplerCreateFlags {
-  eSubsampledEXT = VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT,
-  eSubsampledCoarseReconstructionEXT =
-      VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT
-};
-
-VULKAN_HPP_INLINE std::string to_string(SamplerCreateFlagBits value) {
-  switch (value) {
-  case SamplerCreateFlagBits::eSubsampledEXT:
-    return "SubsampledEXT";
-  case SamplerCreateFlagBits::eSubsampledCoarseReconstructionEXT:
-    return "SubsampledCoarseReconstructionEXT";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class SamplerMipmapMode {
-  eNearest = VK_SAMPLER_MIPMAP_MODE_NEAREST,
-  eLinear = VK_SAMPLER_MIPMAP_MODE_LINEAR
-};
-
-VULKAN_HPP_INLINE std::string to_string(SamplerMipmapMode value) {
-  switch (value) {
-  case SamplerMipmapMode::eNearest:
-    return "Nearest";
-  case SamplerMipmapMode::eLinear:
-    return "Linear";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class SamplerReductionMode {
-  eWeightedAverage = VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE,
-  eMin = VK_SAMPLER_REDUCTION_MODE_MIN,
-  eMax = VK_SAMPLER_REDUCTION_MODE_MAX
-};
-using SamplerReductionModeEXT = SamplerReductionMode;
-
-VULKAN_HPP_INLINE std::string to_string(SamplerReductionMode value) {
-  switch (value) {
-  case SamplerReductionMode::eWeightedAverage:
-    return "WeightedAverage";
-  case SamplerReductionMode::eMin:
-    return "Min";
-  case SamplerReductionMode::eMax:
-    return "Max";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class SamplerYcbcrModelConversion {
-  eRgbIdentity = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY,
-  eYcbcrIdentity = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY,
-  eYcbcr709 = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709,
-  eYcbcr601 = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601,
-  eYcbcr2020 = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020
-};
-using SamplerYcbcrModelConversionKHR = SamplerYcbcrModelConversion;
-
-VULKAN_HPP_INLINE std::string to_string(SamplerYcbcrModelConversion value) {
-  switch (value) {
-  case SamplerYcbcrModelConversion::eRgbIdentity:
-    return "RgbIdentity";
-  case SamplerYcbcrModelConversion::eYcbcrIdentity:
-    return "YcbcrIdentity";
-  case SamplerYcbcrModelConversion::eYcbcr709:
-    return "Ycbcr709";
-  case SamplerYcbcrModelConversion::eYcbcr601:
-    return "Ycbcr601";
-  case SamplerYcbcrModelConversion::eYcbcr2020:
-    return "Ycbcr2020";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class SamplerYcbcrRange {
-  eItuFull = VK_SAMPLER_YCBCR_RANGE_ITU_FULL,
-  eItuNarrow = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW
-};
-using SamplerYcbcrRangeKHR = SamplerYcbcrRange;
-
-VULKAN_HPP_INLINE std::string to_string(SamplerYcbcrRange value) {
-  switch (value) {
-  case SamplerYcbcrRange::eItuFull:
-    return "ItuFull";
-  case SamplerYcbcrRange::eItuNarrow:
-    return "ItuNarrow";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class ScopeNV {
-  eDevice = VK_SCOPE_DEVICE_NV,
-  eWorkgroup = VK_SCOPE_WORKGROUP_NV,
-  eSubgroup = VK_SCOPE_SUBGROUP_NV,
-  eQueueFamily = VK_SCOPE_QUEUE_FAMILY_NV
-};
-
-VULKAN_HPP_INLINE std::string to_string(ScopeNV value) {
-  switch (value) {
-  case ScopeNV::eDevice:
-    return "Device";
-  case ScopeNV::eWorkgroup:
-    return "Workgroup";
-  case ScopeNV::eSubgroup:
-    return "Subgroup";
-  case ScopeNV::eQueueFamily:
-    return "QueueFamily";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class SemaphoreImportFlagBits : VkSemaphoreImportFlags {
-  eTemporary = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT
-};
-using SemaphoreImportFlagBitsKHR = SemaphoreImportFlagBits;
-
-VULKAN_HPP_INLINE std::string to_string(SemaphoreImportFlagBits value) {
-  switch (value) {
-  case SemaphoreImportFlagBits::eTemporary:
-    return "Temporary";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class SemaphoreType {
-  eBinary = VK_SEMAPHORE_TYPE_BINARY,
-  eTimeline = VK_SEMAPHORE_TYPE_TIMELINE
-};
-using SemaphoreTypeKHR = SemaphoreType;
-
-VULKAN_HPP_INLINE std::string to_string(SemaphoreType value) {
-  switch (value) {
-  case SemaphoreType::eBinary:
-    return "Binary";
-  case SemaphoreType::eTimeline:
-    return "Timeline";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class SemaphoreWaitFlagBits : VkSemaphoreWaitFlags {
-  eAny = VK_SEMAPHORE_WAIT_ANY_BIT
-};
-using SemaphoreWaitFlagBitsKHR = SemaphoreWaitFlagBits;
-
-VULKAN_HPP_INLINE std::string to_string(SemaphoreWaitFlagBits value) {
-  switch (value) {
-  case SemaphoreWaitFlagBits::eAny:
-    return "Any";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class ShaderCorePropertiesFlagBitsAMD : VkShaderCorePropertiesFlagsAMD {};
-
-VULKAN_HPP_INLINE std::string to_string(ShaderCorePropertiesFlagBitsAMD) {
-  return "(void)";
-}
-
-enum class ShaderFloatControlsIndependence {
-  e32BitOnly = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY,
-  eAll = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL,
-  eNone = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE
-};
-using ShaderFloatControlsIndependenceKHR = ShaderFloatControlsIndependence;
-
-VULKAN_HPP_INLINE std::string to_string(ShaderFloatControlsIndependence value) {
-  switch (value) {
-  case ShaderFloatControlsIndependence::e32BitOnly:
-    return "32BitOnly";
-  case ShaderFloatControlsIndependence::eAll:
-    return "All";
-  case ShaderFloatControlsIndependence::eNone:
-    return "None";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class ShaderGroupShaderKHR {
-  eGeneral = VK_SHADER_GROUP_SHADER_GENERAL_KHR,
-  eClosestHit = VK_SHADER_GROUP_SHADER_CLOSEST_HIT_KHR,
-  eAnyHit = VK_SHADER_GROUP_SHADER_ANY_HIT_KHR,
-  eIntersection = VK_SHADER_GROUP_SHADER_INTERSECTION_KHR
-};
-
-VULKAN_HPP_INLINE std::string to_string(ShaderGroupShaderKHR value) {
-  switch (value) {
-  case ShaderGroupShaderKHR::eGeneral:
-    return "General";
-  case ShaderGroupShaderKHR::eClosestHit:
-    return "ClosestHit";
-  case ShaderGroupShaderKHR::eAnyHit:
-    return "AnyHit";
-  case ShaderGroupShaderKHR::eIntersection:
-    return "Intersection";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class ShaderInfoTypeAMD {
-  eStatistics = VK_SHADER_INFO_TYPE_STATISTICS_AMD,
-  eBinary = VK_SHADER_INFO_TYPE_BINARY_AMD,
-  eDisassembly = VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD
-};
-
-VULKAN_HPP_INLINE std::string to_string(ShaderInfoTypeAMD value) {
-  switch (value) {
-  case ShaderInfoTypeAMD::eStatistics:
-    return "Statistics";
-  case ShaderInfoTypeAMD::eBinary:
-    return "Binary";
-  case ShaderInfoTypeAMD::eDisassembly:
-    return "Disassembly";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class ShaderModuleCreateFlagBits : VkShaderModuleCreateFlags {};
-
-VULKAN_HPP_INLINE std::string to_string(ShaderModuleCreateFlagBits) {
-  return "(void)";
-}
-
-enum class ShaderStageFlagBits : VkShaderStageFlags {
-  eVertex = VK_SHADER_STAGE_VERTEX_BIT,
-  eTessellationControl = VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT,
-  eTessellationEvaluation = VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT,
-  eGeometry = VK_SHADER_STAGE_GEOMETRY_BIT,
-  eFragment = VK_SHADER_STAGE_FRAGMENT_BIT,
-  eCompute = VK_SHADER_STAGE_COMPUTE_BIT,
-  eAllGraphics = VK_SHADER_STAGE_ALL_GRAPHICS,
-  eAll = VK_SHADER_STAGE_ALL,
-  eRaygenKHR = VK_SHADER_STAGE_RAYGEN_BIT_KHR,
-  eAnyHitKHR = VK_SHADER_STAGE_ANY_HIT_BIT_KHR,
-  eClosestHitKHR = VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR,
-  eMissKHR = VK_SHADER_STAGE_MISS_BIT_KHR,
-  eIntersectionKHR = VK_SHADER_STAGE_INTERSECTION_BIT_KHR,
-  eCallableKHR = VK_SHADER_STAGE_CALLABLE_BIT_KHR,
-  eTaskNV = VK_SHADER_STAGE_TASK_BIT_NV,
-  eMeshNV = VK_SHADER_STAGE_MESH_BIT_NV,
-  eAnyHitNV = VK_SHADER_STAGE_ANY_HIT_BIT_NV,
-  eCallableNV = VK_SHADER_STAGE_CALLABLE_BIT_NV,
-  eClosestHitNV = VK_SHADER_STAGE_CLOSEST_HIT_BIT_NV,
-  eIntersectionNV = VK_SHADER_STAGE_INTERSECTION_BIT_NV,
-  eMissNV = VK_SHADER_STAGE_MISS_BIT_NV,
-  eRaygenNV = VK_SHADER_STAGE_RAYGEN_BIT_NV
-};
-
-VULKAN_HPP_INLINE std::string to_string(ShaderStageFlagBits value) {
-  switch (value) {
-  case ShaderStageFlagBits::eVertex:
-    return "Vertex";
-  case ShaderStageFlagBits::eTessellationControl:
-    return "TessellationControl";
-  case ShaderStageFlagBits::eTessellationEvaluation:
-    return "TessellationEvaluation";
-  case ShaderStageFlagBits::eGeometry:
-    return "Geometry";
-  case ShaderStageFlagBits::eFragment:
-    return "Fragment";
-  case ShaderStageFlagBits::eCompute:
-    return "Compute";
-  case ShaderStageFlagBits::eAllGraphics:
-    return "AllGraphics";
-  case ShaderStageFlagBits::eAll:
-    return "All";
-  case ShaderStageFlagBits::eRaygenKHR:
-    return "RaygenKHR";
-  case ShaderStageFlagBits::eAnyHitKHR:
-    return "AnyHitKHR";
-  case ShaderStageFlagBits::eClosestHitKHR:
-    return "ClosestHitKHR";
-  case ShaderStageFlagBits::eMissKHR:
-    return "MissKHR";
-  case ShaderStageFlagBits::eIntersectionKHR:
-    return "IntersectionKHR";
-  case ShaderStageFlagBits::eCallableKHR:
-    return "CallableKHR";
-  case ShaderStageFlagBits::eTaskNV:
-    return "TaskNV";
-  case ShaderStageFlagBits::eMeshNV:
-    return "MeshNV";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class ShadingRatePaletteEntryNV {
-  eNoInvocations = VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV,
-  e16InvocationsPerPixel =
-      VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV,
-  e8InvocationsPerPixel =
-      VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV,
-  e4InvocationsPerPixel =
-      VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV,
-  e2InvocationsPerPixel =
-      VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV,
-  e1InvocationPerPixel =
-      VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV,
-  e1InvocationPer2X1Pixels =
-      VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV,
-  e1InvocationPer1X2Pixels =
-      VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV,
-  e1InvocationPer2X2Pixels =
-      VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV,
-  e1InvocationPer4X2Pixels =
-      VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV,
-  e1InvocationPer2X4Pixels =
-      VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV,
-  e1InvocationPer4X4Pixels =
-      VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV
-};
-
-VULKAN_HPP_INLINE std::string to_string(ShadingRatePaletteEntryNV value) {
-  switch (value) {
-  case ShadingRatePaletteEntryNV::eNoInvocations:
-    return "NoInvocations";
-  case ShadingRatePaletteEntryNV::e16InvocationsPerPixel:
-    return "16InvocationsPerPixel";
-  case ShadingRatePaletteEntryNV::e8InvocationsPerPixel:
-    return "8InvocationsPerPixel";
-  case ShadingRatePaletteEntryNV::e4InvocationsPerPixel:
-    return "4InvocationsPerPixel";
-  case ShadingRatePaletteEntryNV::e2InvocationsPerPixel:
-    return "2InvocationsPerPixel";
-  case ShadingRatePaletteEntryNV::e1InvocationPerPixel:
-    return "1InvocationPerPixel";
-  case ShadingRatePaletteEntryNV::e1InvocationPer2X1Pixels:
-    return "1InvocationPer2X1Pixels";
-  case ShadingRatePaletteEntryNV::e1InvocationPer1X2Pixels:
-    return "1InvocationPer1X2Pixels";
-  case ShadingRatePaletteEntryNV::e1InvocationPer2X2Pixels:
-    return "1InvocationPer2X2Pixels";
-  case ShadingRatePaletteEntryNV::e1InvocationPer4X2Pixels:
-    return "1InvocationPer4X2Pixels";
-  case ShadingRatePaletteEntryNV::e1InvocationPer2X4Pixels:
-    return "1InvocationPer2X4Pixels";
-  case ShadingRatePaletteEntryNV::e1InvocationPer4X4Pixels:
-    return "1InvocationPer4X4Pixels";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class SharingMode {
-  eExclusive = VK_SHARING_MODE_EXCLUSIVE,
-  eConcurrent = VK_SHARING_MODE_CONCURRENT
-};
-
-VULKAN_HPP_INLINE std::string to_string(SharingMode value) {
-  switch (value) {
-  case SharingMode::eExclusive:
-    return "Exclusive";
-  case SharingMode::eConcurrent:
-    return "Concurrent";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class SparseImageFormatFlagBits : VkSparseImageFormatFlags {
-  eSingleMiptail = VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT,
-  eAlignedMipSize = VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT,
-  eNonstandardBlockSize = VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT
-};
-
-VULKAN_HPP_INLINE std::string to_string(SparseImageFormatFlagBits value) {
-  switch (value) {
-  case SparseImageFormatFlagBits::eSingleMiptail:
-    return "SingleMiptail";
-  case SparseImageFormatFlagBits::eAlignedMipSize:
-    return "AlignedMipSize";
-  case SparseImageFormatFlagBits::eNonstandardBlockSize:
-    return "NonstandardBlockSize";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class SparseMemoryBindFlagBits : VkSparseMemoryBindFlags {
-  eMetadata = VK_SPARSE_MEMORY_BIND_METADATA_BIT
-};
-
-VULKAN_HPP_INLINE std::string to_string(SparseMemoryBindFlagBits value) {
-  switch (value) {
-  case SparseMemoryBindFlagBits::eMetadata:
-    return "Metadata";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class StencilFaceFlagBits : VkStencilFaceFlags {
-  eFront = VK_STENCIL_FACE_FRONT_BIT,
-  eBack = VK_STENCIL_FACE_BACK_BIT,
-  eFrontAndBack = VK_STENCIL_FACE_FRONT_AND_BACK,
-  eVkStencilFrontAndBack = VK_STENCIL_FRONT_AND_BACK
-};
-
-VULKAN_HPP_INLINE std::string to_string(StencilFaceFlagBits value) {
-  switch (value) {
-  case StencilFaceFlagBits::eFront:
-    return "Front";
-  case StencilFaceFlagBits::eBack:
-    return "Back";
-  case StencilFaceFlagBits::eFrontAndBack:
-    return "FrontAndBack";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class StencilOp {
-  eKeep = VK_STENCIL_OP_KEEP,
-  eZero = VK_STENCIL_OP_ZERO,
-  eReplace = VK_STENCIL_OP_REPLACE,
-  eIncrementAndClamp = VK_STENCIL_OP_INCREMENT_AND_CLAMP,
-  eDecrementAndClamp = VK_STENCIL_OP_DECREMENT_AND_CLAMP,
-  eInvert = VK_STENCIL_OP_INVERT,
-  eIncrementAndWrap = VK_STENCIL_OP_INCREMENT_AND_WRAP,
-  eDecrementAndWrap = VK_STENCIL_OP_DECREMENT_AND_WRAP
-};
-
-VULKAN_HPP_INLINE std::string to_string(StencilOp value) {
-  switch (value) {
-  case StencilOp::eKeep:
-    return "Keep";
-  case StencilOp::eZero:
-    return "Zero";
-  case StencilOp::eReplace:
-    return "Replace";
-  case StencilOp::eIncrementAndClamp:
-    return "IncrementAndClamp";
-  case StencilOp::eDecrementAndClamp:
-    return "DecrementAndClamp";
-  case StencilOp::eInvert:
-    return "Invert";
-  case StencilOp::eIncrementAndWrap:
-    return "IncrementAndWrap";
-  case StencilOp::eDecrementAndWrap:
-    return "DecrementAndWrap";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
 enum class StructureType {
-  // clang-format off
-      eApplicationInfo = VK_STRUCTURE_TYPE_APPLICATION_INFO
-    , eInstanceCreateInfo = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO
-    , eDeviceQueueCreateInfo = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO
-    , eDeviceCreateInfo = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO
-    , eSubmitInfo = VK_STRUCTURE_TYPE_SUBMIT_INFO
-    , eMemoryAllocateInfo = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO
-    , eMappedMemoryRange = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE
-    , eBindSparseInfo = VK_STRUCTURE_TYPE_BIND_SPARSE_INFO
-    , eFenceCreateInfo = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO
-    , eSemaphoreCreateInfo = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO
-    , eEventCreateInfo = VK_STRUCTURE_TYPE_EVENT_CREATE_INFO
-    , eQueryPoolCreateInfo = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO
-    , eBufferCreateInfo = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO
-    , eBufferViewCreateInfo = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO
-    , eImageCreateInfo = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO
-    , eImageViewCreateInfo = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO
-    , eShaderModuleCreateInfo = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO
-    , ePipelineCacheCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO
-    , ePipelineShaderStageCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
-    , ePipelineVertexInputStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO
-    , ePipelineInputAssemblyStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO
-    , ePipelineTessellationStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO
-    , ePipelineViewportStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO
-    , ePipelineRasterizationStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO
-    , ePipelineMultisampleStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO
-    , ePipelineDepthStencilStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO
-    , ePipelineColorBlendStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO
-    , ePipelineDynamicStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO
-    , eGraphicsPipelineCreateInfo = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO
-    , eComputePipelineCreateInfo = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO
-    , ePipelineLayoutCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO
-    , eSamplerCreateInfo = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO
-    , eDescriptorSetLayoutCreateInfo = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO
-    , eDescriptorPoolCreateInfo = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO
-    , eDescriptorSetAllocateInfo = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO
-    , eWriteDescriptorSet = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET
-    , eCopyDescriptorSet = VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET
-    , eFramebufferCreateInfo = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO
-    , eRenderPassCreateInfo = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO
-    , eCommandPoolCreateInfo = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO
-    , eCommandBufferAllocateInfo = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO
-    , eCommandBufferInheritanceInfo = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO
-    , eCommandBufferBeginInfo = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO
-    , eRenderPassBeginInfo = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO
-    , eBufferMemoryBarrier = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER
-    , eImageMemoryBarrier = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER
-    , eMemoryBarrier = VK_STRUCTURE_TYPE_MEMORY_BARRIER
-    , eLoaderInstanceCreateInfo = VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO
-    , eLoaderDeviceCreateInfo = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO
-    , ePhysicalDeviceSubgroupProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES
-    , eBindBufferMemoryInfo = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO
-    , eBindImageMemoryInfo = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO
-    , ePhysicalDevice16BitStorageFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES
-    , eMemoryDedicatedRequirements = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS
-    , eMemoryDedicatedAllocateInfo = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO
-    , eMemoryAllocateFlagsInfo = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO
-    , eDeviceGroupRenderPassBeginInfo = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO
-    , eDeviceGroupCommandBufferBeginInfo = VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO
-    , eDeviceGroupSubmitInfo = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO
-    , eDeviceGroupBindSparseInfo = VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO
-    , eBindBufferMemoryDeviceGroupInfo = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO
-    , eBindImageMemoryDeviceGroupInfo = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO
-    , ePhysicalDeviceGroupProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES
-    , eDeviceGroupDeviceCreateInfo = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO
-    , eBufferMemoryRequirementsInfo2 = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2
-    , eImageMemoryRequirementsInfo2 = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2
-    , eImageSparseMemoryRequirementsInfo2 = VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2
-    , eMemoryRequirements2 = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2
-    , eSparseImageMemoryRequirements2 = VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2
-    , ePhysicalDeviceFeatures2 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2
-    , ePhysicalDeviceProperties2 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2
-    , eFormatProperties2 = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2
-    , eImageFormatProperties2 = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2
-    , ePhysicalDeviceImageFormatInfo2 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2
-    , eQueueFamilyProperties2 = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2
-    , ePhysicalDeviceMemoryProperties2 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2
-    , eSparseImageFormatProperties2 = VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2
-    , ePhysicalDeviceSparseImageFormatInfo2 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2
-    , ePhysicalDevicePointClippingProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES
-    , eRenderPassInputAttachmentAspectCreateInfo = VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO
-    , eImageViewUsageCreateInfo = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO
-    , ePipelineTessellationDomainOriginStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO
-    , eRenderPassMultiviewCreateInfo = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO
-    , ePhysicalDeviceMultiviewFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES
-    , ePhysicalDeviceMultiviewProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES
-    , ePhysicalDeviceVariablePointersFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES
-    , eProtectedSubmitInfo = VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO
-    , ePhysicalDeviceProtectedMemoryFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES
-    , ePhysicalDeviceProtectedMemoryProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES
-    , eDeviceQueueInfo2 = VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2
-    , eSamplerYcbcrConversionCreateInfo = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO
-    , eSamplerYcbcrConversionInfo = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO
-    , eBindImagePlaneMemoryInfo = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO
-    , eImagePlaneMemoryRequirementsInfo = VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO
-    , ePhysicalDeviceSamplerYcbcrConversionFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES
-    , eSamplerYcbcrConversionImageFormatProperties = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES
-    , eDescriptorUpdateTemplateCreateInfo = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO
-    , ePhysicalDeviceExternalImageFormatInfo = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO
-    , eExternalImageFormatProperties = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES
-    , ePhysicalDeviceExternalBufferInfo = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO
-    , eExternalBufferProperties = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES
-    , ePhysicalDeviceIdProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES
-    , eExternalMemoryBufferCreateInfo = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO
-    , eExternalMemoryImageCreateInfo = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO
-    , eExportMemoryAllocateInfo = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO
-    , ePhysicalDeviceExternalFenceInfo = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO
-    , eExternalFenceProperties = VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES
-    , eExportFenceCreateInfo = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO
-    , eExportSemaphoreCreateInfo = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO
-    , ePhysicalDeviceExternalSemaphoreInfo = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO
-    , eExternalSemaphoreProperties = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES
-    , ePhysicalDeviceMaintenance3Properties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES
-    , eDescriptorSetLayoutSupport = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT
-    , ePhysicalDeviceShaderDrawParametersFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES
-    , ePhysicalDeviceVulkan11Features = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES
-    , ePhysicalDeviceVulkan11Properties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES
-    , ePhysicalDeviceVulkan12Features = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES
-    , ePhysicalDeviceVulkan12Properties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES
-    , eImageFormatListCreateInfo = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO
-    , eAttachmentDescription2 = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2
-    , eAttachmentReference2 = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2
-    , eSubpassDescription2 = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2
-    , eSubpassDependency2 = VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2
-    , eRenderPassCreateInfo2 = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2
-    , eSubpassBeginInfo = VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO
-    , eSubpassEndInfo = VK_STRUCTURE_TYPE_SUBPASS_END_INFO
-    , ePhysicalDevice8BitStorageFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES
-    , ePhysicalDeviceDriverProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES
-    , ePhysicalDeviceShaderAtomicInt64Features = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES
-    , ePhysicalDeviceShaderFloat16Int8Features = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES
-    , ePhysicalDeviceFloatControlsProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES
-    , eDescriptorSetLayoutBindingFlagsCreateInfo = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO
-    , ePhysicalDeviceDescriptorIndexingFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES
-    , ePhysicalDeviceDescriptorIndexingProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES
-    , eDescriptorSetVariableDescriptorCountAllocateInfo = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO
-    , eDescriptorSetVariableDescriptorCountLayoutSupport = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT
-    , ePhysicalDeviceDepthStencilResolveProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES
-    , eSubpassDescriptionDepthStencilResolve = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE
-    , ePhysicalDeviceScalarBlockLayoutFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES
-    , eImageStencilUsageCreateInfo = VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO
-    , ePhysicalDeviceSamplerFilterMinmaxProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES
-    , eSamplerReductionModeCreateInfo = VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO
-    , ePhysicalDeviceVulkanMemoryModelFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES
-    , ePhysicalDeviceImagelessFramebufferFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES
-    , eFramebufferAttachmentsCreateInfo = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO
-    , eFramebufferAttachmentImageInfo = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO
-    , eRenderPassAttachmentBeginInfo = VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO
-    , ePhysicalDeviceUniformBufferStandardLayoutFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES
-    , ePhysicalDeviceShaderSubgroupExtendedTypesFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES
-    , ePhysicalDeviceSeparateDepthStencilLayoutsFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES
-    , eAttachmentReferenceStencilLayout = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT
-    , eAttachmentDescriptionStencilLayout = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT
-    , ePhysicalDeviceHostQueryResetFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES
-    , ePhysicalDeviceTimelineSemaphoreFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES
-    , ePhysicalDeviceTimelineSemaphoreProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES
-    , eSemaphoreTypeCreateInfo = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO
-    , eTimelineSemaphoreSubmitInfo = VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO
-    , eSemaphoreWaitInfo = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO
-    , eSemaphoreSignalInfo = VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO
-    , ePhysicalDeviceBufferDeviceAddressFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES
-    , eBufferDeviceAddressInfo = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO
-    , eBufferOpaqueCaptureAddressCreateInfo = VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO
-    , eMemoryOpaqueCaptureAddressAllocateInfo = VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO
-    , eDeviceMemoryOpaqueCaptureAddressInfo = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO
-    , eSwapchainCreateInfoKHR = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR
-    , ePresentInfoKHR = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR
-    , eDeviceGroupPresentCapabilitiesKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR
-    , eImageSwapchainCreateInfoKHR = VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR
-    , eBindImageMemorySwapchainInfoKHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR
-    , eAcquireNextImageInfoKHR = VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR
-    , eDeviceGroupPresentInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR
-    , eDeviceGroupSwapchainCreateInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR
-    , eDisplayModeCreateInfoKHR = VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR
-    , eDisplaySurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR
-    , eDisplayPresentInfoKHR = VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR
-#if defined( VK_USE_PLATFORM_XLIB_KHR )
-    , eXlibSurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR
+  eApplicationInfo = VK_STRUCTURE_TYPE_APPLICATION_INFO,
+  eInstanceCreateInfo = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
+  eDeviceQueueCreateInfo = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
+  eDeviceCreateInfo = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
+  eSubmitInfo = VK_STRUCTURE_TYPE_SUBMIT_INFO,
+  eMemoryAllocateInfo = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
+  eMappedMemoryRange = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE,
+  eBindSparseInfo = VK_STRUCTURE_TYPE_BIND_SPARSE_INFO,
+  eFenceCreateInfo = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
+  eSemaphoreCreateInfo = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
+  eEventCreateInfo = VK_STRUCTURE_TYPE_EVENT_CREATE_INFO,
+  eQueryPoolCreateInfo = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO,
+  eBufferCreateInfo = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
+  eBufferViewCreateInfo = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO,
+  eImageCreateInfo = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
+  eImageViewCreateInfo = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
+  eShaderModuleCreateInfo = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,
+  ePipelineCacheCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO,
+  ePipelineShaderStageCreateInfo =
+      VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
+  ePipelineVertexInputStateCreateInfo =
+      VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
+  ePipelineInputAssemblyStateCreateInfo =
+      VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,
+  ePipelineTessellationStateCreateInfo =
+      VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO,
+  ePipelineViewportStateCreateInfo =
+      VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,
+  ePipelineRasterizationStateCreateInfo =
+      VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
+  ePipelineMultisampleStateCreateInfo =
+      VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
+  ePipelineDepthStencilStateCreateInfo =
+      VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,
+  ePipelineColorBlendStateCreateInfo =
+      VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,
+  ePipelineDynamicStateCreateInfo =
+      VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO,
+  eGraphicsPipelineCreateInfo = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
+  eComputePipelineCreateInfo = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
+  ePipelineLayoutCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
+  eSamplerCreateInfo = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
+  eDescriptorSetLayoutCreateInfo =
+      VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
+  eDescriptorPoolCreateInfo = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
+  eDescriptorSetAllocateInfo = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
+  eWriteDescriptorSet = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
+  eCopyDescriptorSet = VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET,
+  eFramebufferCreateInfo = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,
+  eRenderPassCreateInfo = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,
+  eCommandPoolCreateInfo = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
+  eCommandBufferAllocateInfo = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
+  eCommandBufferInheritanceInfo =
+      VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
+  eCommandBufferBeginInfo = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
+  eRenderPassBeginInfo = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
+  eBufferMemoryBarrier = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
+  eImageMemoryBarrier = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
+  eMemoryBarrier = VK_STRUCTURE_TYPE_MEMORY_BARRIER,
+  eLoaderInstanceCreateInfo = VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO,
+  eLoaderDeviceCreateInfo = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO,
+  ePhysicalDeviceSubgroupProperties =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES,
+  eBindBufferMemoryInfo = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO,
+  eBindImageMemoryInfo = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO,
+  ePhysicalDevice16BitStorageFeatures =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES,
+  eMemoryDedicatedRequirements =
+      VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS,
+  eMemoryDedicatedAllocateInfo =
+      VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO,
+  eMemoryAllocateFlagsInfo = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO,
+  eDeviceGroupRenderPassBeginInfo =
+      VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO,
+  eDeviceGroupCommandBufferBeginInfo =
+      VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO,
+  eDeviceGroupSubmitInfo = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO,
+  eDeviceGroupBindSparseInfo = VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO,
+  eBindBufferMemoryDeviceGroupInfo =
+      VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO,
+  eBindImageMemoryDeviceGroupInfo =
+      VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO,
+  ePhysicalDeviceGroupProperties =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES,
+  eDeviceGroupDeviceCreateInfo =
+      VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO,
+  eBufferMemoryRequirementsInfo2 =
+      VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2,
+  eImageMemoryRequirementsInfo2 =
+      VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2,
+  eImageSparseMemoryRequirementsInfo2 =
+      VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2,
+  eMemoryRequirements2 = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2,
+  eSparseImageMemoryRequirements2 =
+      VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2,
+  ePhysicalDeviceFeatures2 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2,
+  ePhysicalDeviceProperties2 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2,
+  eFormatProperties2 = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2,
+  eImageFormatProperties2 = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2,
+  ePhysicalDeviceImageFormatInfo2 =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2,
+  eQueueFamilyProperties2 = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2,
+  ePhysicalDeviceMemoryProperties2 =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2,
+  eSparseImageFormatProperties2 =
+      VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2,
+  ePhysicalDeviceSparseImageFormatInfo2 =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2,
+  ePhysicalDevicePointClippingProperties =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES,
+  eRenderPassInputAttachmentAspectCreateInfo =
+      VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO,
+  eImageViewUsageCreateInfo = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO,
+  ePipelineTessellationDomainOriginStateCreateInfo =
+      VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO,
+  eRenderPassMultiviewCreateInfo =
+      VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO,
+  ePhysicalDeviceMultiviewFeatures =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES,
+  ePhysicalDeviceMultiviewProperties =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES,
+  ePhysicalDeviceVariablePointersFeatures =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES,
+  eProtectedSubmitInfo = VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO,
+  ePhysicalDeviceProtectedMemoryFeatures =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES,
+  ePhysicalDeviceProtectedMemoryProperties =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES,
+  eDeviceQueueInfo2 = VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2,
+  eSamplerYcbcrConversionCreateInfo =
+      VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO,
+  eSamplerYcbcrConversionInfo = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO,
+  eBindImagePlaneMemoryInfo = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO,
+  eImagePlaneMemoryRequirementsInfo =
+      VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO,
+  ePhysicalDeviceSamplerYcbcrConversionFeatures =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES,
+  eSamplerYcbcrConversionImageFormatProperties =
+      VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES,
+  eDescriptorUpdateTemplateCreateInfo =
+      VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO,
+  ePhysicalDeviceExternalImageFormatInfo =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO,
+  eExternalImageFormatProperties =
+      VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES,
+  ePhysicalDeviceExternalBufferInfo =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO,
+  eExternalBufferProperties = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES,
+  ePhysicalDeviceIdProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES,
+  eExternalMemoryBufferCreateInfo =
+      VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO,
+  eExternalMemoryImageCreateInfo =
+      VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO,
+  eExportMemoryAllocateInfo = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO,
+  ePhysicalDeviceExternalFenceInfo =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO,
+  eExternalFenceProperties = VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES,
+  eExportFenceCreateInfo = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO,
+  eExportSemaphoreCreateInfo = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO,
+  ePhysicalDeviceExternalSemaphoreInfo =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO,
+  eExternalSemaphoreProperties =
+      VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES,
+  ePhysicalDeviceMaintenance3Properties =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES,
+  eDescriptorSetLayoutSupport = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT,
+  ePhysicalDeviceShaderDrawParametersFeatures =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES,
+  ePhysicalDeviceVulkan11Features =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES,
+  ePhysicalDeviceVulkan11Properties =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES,
+  ePhysicalDeviceVulkan12Features =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES,
+  ePhysicalDeviceVulkan12Properties =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES,
+  eImageFormatListCreateInfo = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO,
+  eAttachmentDescription2 = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2,
+  eAttachmentReference2 = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2,
+  eSubpassDescription2 = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2,
+  eSubpassDependency2 = VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2,
+  eRenderPassCreateInfo2 = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2,
+  eSubpassBeginInfo = VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO,
+  eSubpassEndInfo = VK_STRUCTURE_TYPE_SUBPASS_END_INFO,
+  ePhysicalDevice8BitStorageFeatures =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES,
+  ePhysicalDeviceDriverProperties =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES,
+  ePhysicalDeviceShaderAtomicInt64Features =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES,
+  ePhysicalDeviceShaderFloat16Int8Features =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES,
+  ePhysicalDeviceFloatControlsProperties =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES,
+  eDescriptorSetLayoutBindingFlagsCreateInfo =
+      VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO,
+  ePhysicalDeviceDescriptorIndexingFeatures =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES,
+  ePhysicalDeviceDescriptorIndexingProperties =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES,
+  eDescriptorSetVariableDescriptorCountAllocateInfo =
+      VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO,
+  eDescriptorSetVariableDescriptorCountLayoutSupport =
+      VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT,
+  ePhysicalDeviceDepthStencilResolveProperties =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES,
+  eSubpassDescriptionDepthStencilResolve =
+      VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE,
+  ePhysicalDeviceScalarBlockLayoutFeatures =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES,
+  eImageStencilUsageCreateInfo =
+      VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO,
+  ePhysicalDeviceSamplerFilterMinmaxProperties =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES,
+  eSamplerReductionModeCreateInfo =
+      VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO,
+  ePhysicalDeviceVulkanMemoryModelFeatures =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES,
+  ePhysicalDeviceImagelessFramebufferFeatures =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES,
+  eFramebufferAttachmentsCreateInfo =
+      VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO,
+  eFramebufferAttachmentImageInfo =
+      VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO,
+  eRenderPassAttachmentBeginInfo =
+      VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO,
+  ePhysicalDeviceUniformBufferStandardLayoutFeatures =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES,
+  ePhysicalDeviceShaderSubgroupExtendedTypesFeatures =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES,
+  ePhysicalDeviceSeparateDepthStencilLayoutsFeatures =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES,
+  eAttachmentReferenceStencilLayout =
+      VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT,
+  eAttachmentDescriptionStencilLayout =
+      VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT,
+  ePhysicalDeviceHostQueryResetFeatures =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES,
+  ePhysicalDeviceTimelineSemaphoreFeatures =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES,
+  ePhysicalDeviceTimelineSemaphoreProperties =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES,
+  eSemaphoreTypeCreateInfo = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO,
+  eTimelineSemaphoreSubmitInfo =
+      VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO,
+  eSemaphoreWaitInfo = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO,
+  eSemaphoreSignalInfo = VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO,
+  ePhysicalDeviceBufferDeviceAddressFeatures =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES,
+  eBufferDeviceAddressInfo = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO,
+  eBufferOpaqueCaptureAddressCreateInfo =
+      VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO,
+  eMemoryOpaqueCaptureAddressAllocateInfo =
+      VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO,
+  eDeviceMemoryOpaqueCaptureAddressInfo =
+      VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO,
+  eSwapchainCreateInfoKHR = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR,
+  ePresentInfoKHR = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
+  eDeviceGroupPresentCapabilitiesKHR =
+      VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR,
+  eImageSwapchainCreateInfoKHR =
+      VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR,
+  eBindImageMemorySwapchainInfoKHR =
+      VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR,
+  eAcquireNextImageInfoKHR = VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR,
+  eDeviceGroupPresentInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR,
+  eDeviceGroupSwapchainCreateInfoKHR =
+      VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR,
+  eDisplayModeCreateInfoKHR = VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR,
+  eDisplaySurfaceCreateInfoKHR =
+      VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR,
+  eDisplayPresentInfoKHR = VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR,
+#if defined(VK_USE_PLATFORM_XLIB_KHR)
+  eXlibSurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR,
 #endif /*VK_USE_PLATFORM_XLIB_KHR*/
-#if defined( VK_USE_PLATFORM_XCB_KHR )
-    , eXcbSurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR
+#if defined(VK_USE_PLATFORM_XCB_KHR)
+  eXcbSurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR,
 #endif /*VK_USE_PLATFORM_XCB_KHR*/
-#if defined( VK_USE_PLATFORM_WAYLAND_KHR )
-    , eWaylandSurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR
+#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
+  eWaylandSurfaceCreateInfoKHR =
+      VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR,
 #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
-#if defined( VK_USE_PLATFORM_ANDROID_KHR )
-    , eAndroidSurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR
+#if defined(VK_USE_PLATFORM_ANDROID_KHR)
+  eAndroidSurfaceCreateInfoKHR =
+      VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR,
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
-#if defined( VK_USE_PLATFORM_WIN32_KHR )
-    , eWin32SurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR
+#if defined(VK_USE_PLATFORM_WIN32_KHR)
+  eWin32SurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR,
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
-    , eDebugReportCallbackCreateInfoEXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT
-    , ePipelineRasterizationStateRasterizationOrderAMD = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD
-    , eDebugMarkerObjectNameInfoEXT = VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT
-    , eDebugMarkerObjectTagInfoEXT = VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT
-    , eDebugMarkerMarkerInfoEXT = VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT
-    , eDedicatedAllocationImageCreateInfoNV = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV
-    , eDedicatedAllocationBufferCreateInfoNV = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV
-    , eDedicatedAllocationMemoryAllocateInfoNV = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV
-    , ePhysicalDeviceTransformFeedbackFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT
-    , ePhysicalDeviceTransformFeedbackPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT
-    , ePipelineRasterizationStateStreamCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT
-    , eImageViewHandleInfoNVX = VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX
-    , eImageViewAddressPropertiesNVX = VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX
-    , eTextureLodGatherFormatPropertiesAMD = VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD
-#if defined( VK_USE_PLATFORM_GGP )
-    , eStreamDescriptorSurfaceCreateInfoGGP = VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP
+  eDebugReportCallbackCreateInfoEXT =
+      VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT,
+  ePipelineRasterizationStateRasterizationOrderAMD =
+      VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD,
+  eDebugMarkerObjectNameInfoEXT =
+      VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT,
+  eDebugMarkerObjectTagInfoEXT =
+      VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT,
+  eDebugMarkerMarkerInfoEXT = VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT,
+  eDedicatedAllocationImageCreateInfoNV =
+      VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV,
+  eDedicatedAllocationBufferCreateInfoNV =
+      VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV,
+  eDedicatedAllocationMemoryAllocateInfoNV =
+      VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV,
+  ePhysicalDeviceTransformFeedbackFeaturesEXT =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT,
+  ePhysicalDeviceTransformFeedbackPropertiesEXT =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT,
+  ePipelineRasterizationStateStreamCreateInfoEXT =
+      VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT,
+  eImageViewHandleInfoNVX = VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX,
+  eImageViewAddressPropertiesNVX =
+      VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX,
+  eTextureLodGatherFormatPropertiesAMD =
+      VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD,
+#if defined(VK_USE_PLATFORM_GGP)
+  eStreamDescriptorSurfaceCreateInfoGGP =
+      VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP,
 #endif /*VK_USE_PLATFORM_GGP*/
-    , ePhysicalDeviceCornerSampledImageFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV
-    , eExternalMemoryImageCreateInfoNV = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV
-    , eExportMemoryAllocateInfoNV = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV
-#if defined( VK_USE_PLATFORM_WIN32_KHR )
-    , eImportMemoryWin32HandleInfoNV = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV
-    , eExportMemoryWin32HandleInfoNV = VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV
-    , eWin32KeyedMutexAcquireReleaseInfoNV = VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV
+  ePhysicalDeviceCornerSampledImageFeaturesNV =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV,
+  eExternalMemoryImageCreateInfoNV =
+      VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV,
+  eExportMemoryAllocateInfoNV =
+      VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV,
+#if defined(VK_USE_PLATFORM_WIN32_KHR)
+  eImportMemoryWin32HandleInfoNV =
+      VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV,
+  eExportMemoryWin32HandleInfoNV =
+      VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV,
+  eWin32KeyedMutexAcquireReleaseInfoNV =
+      VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV,
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
-    , eValidationFlagsEXT = VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT
-#if defined( VK_USE_PLATFORM_VI_NN )
-    , eViSurfaceCreateInfoNN = VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN
+  eValidationFlagsEXT = VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT,
+#if defined(VK_USE_PLATFORM_VI_NN)
+  eViSurfaceCreateInfoNN = VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN,
 #endif /*VK_USE_PLATFORM_VI_NN*/
-    , ePhysicalDeviceTextureCompressionAstcHdrFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT
-    , eImageViewAstcDecodeModeEXT = VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT
-    , ePhysicalDeviceAstcDecodeFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT
-#if defined( VK_USE_PLATFORM_WIN32_KHR )
-    , eImportMemoryWin32HandleInfoKHR = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR
-    , eExportMemoryWin32HandleInfoKHR = VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR
-    , eMemoryWin32HandlePropertiesKHR = VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR
-    , eMemoryGetWin32HandleInfoKHR = VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR
+  ePhysicalDeviceTextureCompressionAstcHdrFeaturesEXT =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT,
+  eImageViewAstcDecodeModeEXT =
+      VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT,
+  ePhysicalDeviceAstcDecodeFeaturesEXT =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT,
+#if defined(VK_USE_PLATFORM_WIN32_KHR)
+  eImportMemoryWin32HandleInfoKHR =
+      VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR,
+  eExportMemoryWin32HandleInfoKHR =
+      VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR,
+  eMemoryWin32HandlePropertiesKHR =
+      VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR,
+  eMemoryGetWin32HandleInfoKHR =
+      VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR,
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
-    , eImportMemoryFdInfoKHR = VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR
-    , eMemoryFdPropertiesKHR = VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR
-    , eMemoryGetFdInfoKHR = VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR
-#if defined( VK_USE_PLATFORM_WIN32_KHR )
-    , eWin32KeyedMutexAcquireReleaseInfoKHR = VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR
-    , eImportSemaphoreWin32HandleInfoKHR = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR
-    , eExportSemaphoreWin32HandleInfoKHR = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR
-    , eD3D12FenceSubmitInfoKHR = VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR
-    , eSemaphoreGetWin32HandleInfoKHR = VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR
+  eImportMemoryFdInfoKHR = VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR,
+  eMemoryFdPropertiesKHR = VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR,
+  eMemoryGetFdInfoKHR = VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR,
+#if defined(VK_USE_PLATFORM_WIN32_KHR)
+  eWin32KeyedMutexAcquireReleaseInfoKHR =
+      VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR,
+  eImportSemaphoreWin32HandleInfoKHR =
+      VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR,
+  eExportSemaphoreWin32HandleInfoKHR =
+      VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR,
+  eD3D12FenceSubmitInfoKHR = VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR,
+  eSemaphoreGetWin32HandleInfoKHR =
+      VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR,
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
-    , eImportSemaphoreFdInfoKHR = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR
-    , eSemaphoreGetFdInfoKHR = VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR
-    , ePhysicalDevicePushDescriptorPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR
-    , eCommandBufferInheritanceConditionalRenderingInfoEXT = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT
-    , ePhysicalDeviceConditionalRenderingFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT
-    , eConditionalRenderingBeginInfoEXT = VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT
-    , ePresentRegionsKHR = VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR
-    , ePipelineViewportWScalingStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV
-    , eSurfaceCapabilities2EXT = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT
-    , eDisplayPowerInfoEXT = VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT
-    , eDeviceEventInfoEXT = VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT
-    , eDisplayEventInfoEXT = VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT
-    , eSwapchainCounterCreateInfoEXT = VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT
-    , ePresentTimesInfoGOOGLE = VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE
-    , ePhysicalDeviceMultiviewPerViewAttributesPropertiesNVX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX
-    , ePipelineViewportSwizzleStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV
-    , ePhysicalDeviceDiscardRectanglePropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT
-    , ePipelineDiscardRectangleStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT
-    , ePhysicalDeviceConservativeRasterizationPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT
-    , ePipelineRasterizationConservativeStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT
-    , ePhysicalDeviceDepthClipEnableFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT
-    , ePipelineRasterizationDepthClipStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT
-    , eHdrMetadataEXT = VK_STRUCTURE_TYPE_HDR_METADATA_EXT
-    , eSharedPresentSurfaceCapabilitiesKHR = VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR
-#if defined( VK_USE_PLATFORM_WIN32_KHR )
-    , eImportFenceWin32HandleInfoKHR = VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR
-    , eExportFenceWin32HandleInfoKHR = VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR
-    , eFenceGetWin32HandleInfoKHR = VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR
+  eImportSemaphoreFdInfoKHR = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR,
+  eSemaphoreGetFdInfoKHR = VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR,
+  ePhysicalDevicePushDescriptorPropertiesKHR =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR,
+  eCommandBufferInheritanceConditionalRenderingInfoEXT =
+      VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT,
+  ePhysicalDeviceConditionalRenderingFeaturesEXT =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT,
+  eConditionalRenderingBeginInfoEXT =
+      VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT,
+  ePresentRegionsKHR = VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR,
+  ePipelineViewportWScalingStateCreateInfoNV =
+      VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV,
+  eSurfaceCapabilities2EXT = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT,
+  eDisplayPowerInfoEXT = VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT,
+  eDeviceEventInfoEXT = VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT,
+  eDisplayEventInfoEXT = VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT,
+  eSwapchainCounterCreateInfoEXT =
+      VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT,
+  ePresentTimesInfoGOOGLE = VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE,
+  ePhysicalDeviceMultiviewPerViewAttributesPropertiesNVX =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX,
+  ePipelineViewportSwizzleStateCreateInfoNV =
+      VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV,
+  ePhysicalDeviceDiscardRectanglePropertiesEXT =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT,
+  ePipelineDiscardRectangleStateCreateInfoEXT =
+      VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT,
+  ePhysicalDeviceConservativeRasterizationPropertiesEXT =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT,
+  ePipelineRasterizationConservativeStateCreateInfoEXT =
+      VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT,
+  ePhysicalDeviceDepthClipEnableFeaturesEXT =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT,
+  ePipelineRasterizationDepthClipStateCreateInfoEXT =
+      VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT,
+  eHdrMetadataEXT = VK_STRUCTURE_TYPE_HDR_METADATA_EXT,
+  eSharedPresentSurfaceCapabilitiesKHR =
+      VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR,
+#if defined(VK_USE_PLATFORM_WIN32_KHR)
+  eImportFenceWin32HandleInfoKHR =
+      VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR,
+  eExportFenceWin32HandleInfoKHR =
+      VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR,
+  eFenceGetWin32HandleInfoKHR =
+      VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR,
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
-    , eImportFenceFdInfoKHR = VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR
-    , eFenceGetFdInfoKHR = VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR
-    , ePhysicalDevicePerformanceQueryFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR
-    , ePhysicalDevicePerformanceQueryPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR
-    , eQueryPoolPerformanceCreateInfoKHR = VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR
-    , ePerformanceQuerySubmitInfoKHR = VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR
-    , eAcquireProfilingLockInfoKHR = VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR
-    , ePerformanceCounterKHR = VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR
-    , ePerformanceCounterDescriptionKHR = VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR
-    , ePhysicalDeviceSurfaceInfo2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR
-    , eSurfaceCapabilities2KHR = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR
-    , eSurfaceFormat2KHR = VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR
-    , eDisplayProperties2KHR = VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR
-    , eDisplayPlaneProperties2KHR = VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR
-    , eDisplayModeProperties2KHR = VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR
-    , eDisplayPlaneInfo2KHR = VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR
-    , eDisplayPlaneCapabilities2KHR = VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR
-#if defined( VK_USE_PLATFORM_IOS_MVK )
-    , eIosSurfaceCreateInfoMVK = VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK
+  eImportFenceFdInfoKHR = VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR,
+  eFenceGetFdInfoKHR = VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR,
+  ePhysicalDevicePerformanceQueryFeaturesKHR =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR,
+  ePhysicalDevicePerformanceQueryPropertiesKHR =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR,
+  eQueryPoolPerformanceCreateInfoKHR =
+      VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR,
+  ePerformanceQuerySubmitInfoKHR =
+      VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR,
+  eAcquireProfilingLockInfoKHR =
+      VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR,
+  ePerformanceCounterKHR = VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR,
+  ePerformanceCounterDescriptionKHR =
+      VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR,
+  ePhysicalDeviceSurfaceInfo2KHR =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR,
+  eSurfaceCapabilities2KHR = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR,
+  eSurfaceFormat2KHR = VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR,
+  eDisplayProperties2KHR = VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR,
+  eDisplayPlaneProperties2KHR =
+      VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR,
+  eDisplayModeProperties2KHR = VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR,
+  eDisplayPlaneInfo2KHR = VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR,
+  eDisplayPlaneCapabilities2KHR =
+      VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR,
+#if defined(VK_USE_PLATFORM_IOS_MVK)
+  eIosSurfaceCreateInfoMVK = VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK,
 #endif /*VK_USE_PLATFORM_IOS_MVK*/
-#if defined( VK_USE_PLATFORM_MACOS_MVK )
-    , eMacosSurfaceCreateInfoMVK = VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK
+#if defined(VK_USE_PLATFORM_MACOS_MVK)
+  eMacosSurfaceCreateInfoMVK = VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK,
 #endif /*VK_USE_PLATFORM_MACOS_MVK*/
-    , eDebugUtilsObjectNameInfoEXT = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT
-    , eDebugUtilsObjectTagInfoEXT = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT
-    , eDebugUtilsLabelEXT = VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT
-    , eDebugUtilsMessengerCallbackDataEXT = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT
-    , eDebugUtilsMessengerCreateInfoEXT = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT
-#if defined( VK_USE_PLATFORM_ANDROID_KHR )
-    , eAndroidHardwareBufferUsageANDROID = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID
-    , eAndroidHardwareBufferPropertiesANDROID = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID
-    , eAndroidHardwareBufferFormatPropertiesANDROID = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID
-    , eImportAndroidHardwareBufferInfoANDROID = VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID
-    , eMemoryGetAndroidHardwareBufferInfoANDROID = VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID
-    , eExternalFormatANDROID = VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID
+  eDebugUtilsObjectNameInfoEXT =
+      VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT,
+  eDebugUtilsObjectTagInfoEXT =
+      VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT,
+  eDebugUtilsLabelEXT = VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT,
+  eDebugUtilsMessengerCallbackDataEXT =
+      VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT,
+  eDebugUtilsMessengerCreateInfoEXT =
+      VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT,
+#if defined(VK_USE_PLATFORM_ANDROID_KHR)
+  eAndroidHardwareBufferUsageANDROID =
+      VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID,
+  eAndroidHardwareBufferPropertiesANDROID =
+      VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID,
+  eAndroidHardwareBufferFormatPropertiesANDROID =
+      VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID,
+  eImportAndroidHardwareBufferInfoANDROID =
+      VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID,
+  eMemoryGetAndroidHardwareBufferInfoANDROID =
+      VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID,
+  eExternalFormatANDROID = VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID,
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
-    , ePhysicalDeviceInlineUniformBlockFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT
-    , ePhysicalDeviceInlineUniformBlockPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT
-    , eWriteDescriptorSetInlineUniformBlockEXT = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT
-    , eDescriptorPoolInlineUniformBlockCreateInfoEXT = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT
-    , eSampleLocationsInfoEXT = VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT
-    , eRenderPassSampleLocationsBeginInfoEXT = VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT
-    , ePipelineSampleLocationsStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT
-    , ePhysicalDeviceSampleLocationsPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT
-    , eMultisamplePropertiesEXT = VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT
-    , ePhysicalDeviceBlendOperationAdvancedFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT
-    , ePhysicalDeviceBlendOperationAdvancedPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT
-    , ePipelineColorBlendAdvancedStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT
-    , ePipelineCoverageToColorStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV
-    , eWriteDescriptorSetAccelerationStructureKHR = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR
-    , eAccelerationStructureBuildGeometryInfoKHR = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR
-    , eAccelerationStructureDeviceAddressInfoKHR = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR
-    , eAccelerationStructureGeometryAabbsDataKHR = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR
-    , eAccelerationStructureGeometryInstancesDataKHR = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR
-    , eAccelerationStructureGeometryTrianglesDataKHR = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR
-    , eAccelerationStructureGeometryKHR = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR
-    , eAccelerationStructureVersionInfoKHR = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR
-    , eCopyAccelerationStructureInfoKHR = VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR
-    , eCopyAccelerationStructureToMemoryInfoKHR = VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR
-    , eCopyMemoryToAccelerationStructureInfoKHR = VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR
-    , ePhysicalDeviceAccelerationStructureFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR
-    , ePhysicalDeviceAccelerationStructurePropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR
-    , eAccelerationStructureCreateInfoKHR = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR
-    , eAccelerationStructureBuildSizesInfoKHR = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR
-    , ePhysicalDeviceRayTracingPipelineFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR
-    , ePhysicalDeviceRayTracingPipelinePropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR
-    , eRayTracingPipelineCreateInfoKHR = VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR
-    , eRayTracingShaderGroupCreateInfoKHR = VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR
-    , eRayTracingPipelineInterfaceCreateInfoKHR = VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR
-    , ePhysicalDeviceRayQueryFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR
-    , ePipelineCoverageModulationStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV
-    , ePhysicalDeviceShaderSmBuiltinsFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV
-    , ePhysicalDeviceShaderSmBuiltinsPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV
-    , eDrmFormatModifierPropertiesListEXT = VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT
-    , ePhysicalDeviceImageDrmFormatModifierInfoEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT
-    , eImageDrmFormatModifierListCreateInfoEXT = VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT
-    , eImageDrmFormatModifierExplicitCreateInfoEXT = VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT
-    , eImageDrmFormatModifierPropertiesEXT = VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT
-    , eValidationCacheCreateInfoEXT = VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT
-    , eShaderModuleValidationCacheCreateInfoEXT = VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT
-#if defined( VK_ENABLE_BETA_EXTENSIONS )
-    , ePhysicalDevicePortabilitySubsetFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR
-    , ePhysicalDevicePortabilitySubsetPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR
+  ePhysicalDeviceInlineUniformBlockFeaturesEXT =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT,
+  ePhysicalDeviceInlineUniformBlockPropertiesEXT =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT,
+  eWriteDescriptorSetInlineUniformBlockEXT =
+      VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT,
+  eDescriptorPoolInlineUniformBlockCreateInfoEXT =
+      VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT,
+  eSampleLocationsInfoEXT = VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT,
+  eRenderPassSampleLocationsBeginInfoEXT =
+      VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT,
+  ePipelineSampleLocationsStateCreateInfoEXT =
+      VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT,
+  ePhysicalDeviceSampleLocationsPropertiesEXT =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT,
+  eMultisamplePropertiesEXT = VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT,
+  ePhysicalDeviceBlendOperationAdvancedFeaturesEXT =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT,
+  ePhysicalDeviceBlendOperationAdvancedPropertiesEXT =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT,
+  ePipelineColorBlendAdvancedStateCreateInfoEXT =
+      VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT,
+  ePipelineCoverageToColorStateCreateInfoNV =
+      VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV,
+  eWriteDescriptorSetAccelerationStructureKHR =
+      VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR,
+  eAccelerationStructureBuildGeometryInfoKHR =
+      VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR,
+  eAccelerationStructureDeviceAddressInfoKHR =
+      VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR,
+  eAccelerationStructureGeometryAabbsDataKHR =
+      VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR,
+  eAccelerationStructureGeometryInstancesDataKHR =
+      VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR,
+  eAccelerationStructureGeometryTrianglesDataKHR =
+      VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR,
+  eAccelerationStructureGeometryKHR =
+      VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR,
+  eAccelerationStructureVersionInfoKHR =
+      VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR,
+  eCopyAccelerationStructureInfoKHR =
+      VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR,
+  eCopyAccelerationStructureToMemoryInfoKHR =
+      VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR,
+  eCopyMemoryToAccelerationStructureInfoKHR =
+      VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR,
+  ePhysicalDeviceAccelerationStructureFeaturesKHR =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR,
+  ePhysicalDeviceAccelerationStructurePropertiesKHR =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR,
+  eAccelerationStructureCreateInfoKHR =
+      VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR,
+  eAccelerationStructureBuildSizesInfoKHR =
+      VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR,
+  ePhysicalDeviceRayTracingPipelineFeaturesKHR =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR,
+  ePhysicalDeviceRayTracingPipelinePropertiesKHR =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR,
+  eRayTracingPipelineCreateInfoKHR =
+      VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR,
+  eRayTracingShaderGroupCreateInfoKHR =
+      VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR,
+  eRayTracingPipelineInterfaceCreateInfoKHR =
+      VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR,
+  ePhysicalDeviceRayQueryFeaturesKHR =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR,
+  ePipelineCoverageModulationStateCreateInfoNV =
+      VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV,
+  ePhysicalDeviceShaderSmBuiltinsFeaturesNV =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV,
+  ePhysicalDeviceShaderSmBuiltinsPropertiesNV =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV,
+  eDrmFormatModifierPropertiesListEXT =
+      VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT,
+  ePhysicalDeviceImageDrmFormatModifierInfoEXT =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT,
+  eImageDrmFormatModifierListCreateInfoEXT =
+      VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT,
+  eImageDrmFormatModifierExplicitCreateInfoEXT =
+      VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT,
+  eImageDrmFormatModifierPropertiesEXT =
+      VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT,
+  eValidationCacheCreateInfoEXT =
+      VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT,
+  eShaderModuleValidationCacheCreateInfoEXT =
+      VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT,
+#if defined(VK_ENABLE_BETA_EXTENSIONS)
+  ePhysicalDevicePortabilitySubsetFeaturesKHR =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR,
+  ePhysicalDevicePortabilitySubsetPropertiesKHR =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR,
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
-    , ePipelineViewportShadingRateImageStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV
-    , ePhysicalDeviceShadingRateImageFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV
-    , ePhysicalDeviceShadingRateImagePropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV
-    , ePipelineViewportCoarseSampleOrderStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV
-    , eRayTracingPipelineCreateInfoNV = VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV
-    , eAccelerationStructureCreateInfoNV = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV
-    , eGeometryNV = VK_STRUCTURE_TYPE_GEOMETRY_NV
-    , eGeometryTrianglesNV = VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV
-    , eGeometryAabbNV = VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV
-    , eBindAccelerationStructureMemoryInfoNV = VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV
-    , eWriteDescriptorSetAccelerationStructureNV = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV
-    , eAccelerationStructureMemoryRequirementsInfoNV = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV
-    , ePhysicalDeviceRayTracingPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV
-    , eRayTracingShaderGroupCreateInfoNV = VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV
-    , eAccelerationStructureInfoNV = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV
-    , ePhysicalDeviceRepresentativeFragmentTestFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV
-    , ePipelineRepresentativeFragmentTestStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV
-    , ePhysicalDeviceImageViewImageFormatInfoEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT
-    , eFilterCubicImageViewImageFormatPropertiesEXT = VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT
-    , eDeviceQueueGlobalPriorityCreateInfoEXT = VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT
-    , eImportMemoryHostPointerInfoEXT = VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT
-    , eMemoryHostPointerPropertiesEXT = VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT
-    , ePhysicalDeviceExternalMemoryHostPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT
-    , ePhysicalDeviceShaderClockFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR
-    , ePipelineCompilerControlCreateInfoAMD = VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD
-    , eCalibratedTimestampInfoEXT = VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT
-    , ePhysicalDeviceShaderCorePropertiesAMD = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD
-    , eDeviceMemoryOverallocationCreateInfoAMD = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD
-    , ePhysicalDeviceVertexAttributeDivisorPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT
-    , ePipelineVertexInputDivisorStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT
-    , ePhysicalDeviceVertexAttributeDivisorFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT
-#if defined( VK_USE_PLATFORM_GGP )
-    , ePresentFrameTokenGGP = VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP
+  ePipelineViewportShadingRateImageStateCreateInfoNV =
+      VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV,
+  ePhysicalDeviceShadingRateImageFeaturesNV =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV,
+  ePhysicalDeviceShadingRateImagePropertiesNV =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV,
+  ePipelineViewportCoarseSampleOrderStateCreateInfoNV =
+      VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV,
+  eRayTracingPipelineCreateInfoNV =
+      VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV,
+  eAccelerationStructureCreateInfoNV =
+      VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV,
+  eGeometryNV = VK_STRUCTURE_TYPE_GEOMETRY_NV,
+  eGeometryTrianglesNV = VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV,
+  eGeometryAabbNV = VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV,
+  eBindAccelerationStructureMemoryInfoNV =
+      VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV,
+  eWriteDescriptorSetAccelerationStructureNV =
+      VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV,
+  eAccelerationStructureMemoryRequirementsInfoNV =
+      VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV,
+  ePhysicalDeviceRayTracingPropertiesNV =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV,
+  eRayTracingShaderGroupCreateInfoNV =
+      VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV,
+  eAccelerationStructureInfoNV =
+      VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV,
+  ePhysicalDeviceRepresentativeFragmentTestFeaturesNV =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV,
+  ePipelineRepresentativeFragmentTestStateCreateInfoNV =
+      VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV,
+  ePhysicalDeviceImageViewImageFormatInfoEXT =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT,
+  eFilterCubicImageViewImageFormatPropertiesEXT =
+      VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT,
+  eDeviceQueueGlobalPriorityCreateInfoEXT =
+      VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT,
+  eImportMemoryHostPointerInfoEXT =
+      VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT,
+  eMemoryHostPointerPropertiesEXT =
+      VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT,
+  ePhysicalDeviceExternalMemoryHostPropertiesEXT =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT,
+  ePhysicalDeviceShaderClockFeaturesKHR =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR,
+  ePipelineCompilerControlCreateInfoAMD =
+      VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD,
+  eCalibratedTimestampInfoEXT = VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT,
+  ePhysicalDeviceShaderCorePropertiesAMD =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD,
+  eDeviceMemoryOverallocationCreateInfoAMD =
+      VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD,
+  ePhysicalDeviceVertexAttributeDivisorPropertiesEXT =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT,
+  ePipelineVertexInputDivisorStateCreateInfoEXT =
+      VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT,
+  ePhysicalDeviceVertexAttributeDivisorFeaturesEXT =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT,
+#if defined(VK_USE_PLATFORM_GGP)
+  ePresentFrameTokenGGP = VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP,
 #endif /*VK_USE_PLATFORM_GGP*/
-    , ePipelineCreationFeedbackCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT
-    , ePhysicalDeviceComputeShaderDerivativesFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV
-    , ePhysicalDeviceMeshShaderFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV
-    , ePhysicalDeviceMeshShaderPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV
-    , ePhysicalDeviceFragmentShaderBarycentricFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV
-    , ePhysicalDeviceShaderImageFootprintFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV
-    , ePipelineViewportExclusiveScissorStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV
-    , ePhysicalDeviceExclusiveScissorFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV
-    , eCheckpointDataNV = VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV
-    , eQueueFamilyCheckpointPropertiesNV = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV
-    , ePhysicalDeviceShaderIntegerFunctions2FeaturesINTEL = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL
-    , eQueryPoolPerformanceQueryCreateInfoINTEL = VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL
-    , eInitializePerformanceApiInfoINTEL = VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL
-    , ePerformanceMarkerInfoINTEL = VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL
-    , ePerformanceStreamMarkerInfoINTEL = VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL
-    , ePerformanceOverrideInfoINTEL = VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL
-    , ePerformanceConfigurationAcquireInfoINTEL = VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL
-    , ePhysicalDevicePciBusInfoPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT
-    , eDisplayNativeHdrSurfaceCapabilitiesAMD = VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD
-    , eSwapchainDisplayNativeHdrCreateInfoAMD = VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD
-#if defined( VK_USE_PLATFORM_FUCHSIA )
-    , eImagepipeSurfaceCreateInfoFUCHSIA = VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA
+  ePipelineCreationFeedbackCreateInfoEXT =
+      VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT,
+  ePhysicalDeviceComputeShaderDerivativesFeaturesNV =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV,
+  ePhysicalDeviceMeshShaderFeaturesNV =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV,
+  ePhysicalDeviceMeshShaderPropertiesNV =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV,
+  ePhysicalDeviceFragmentShaderBarycentricFeaturesNV =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV,
+  ePhysicalDeviceShaderImageFootprintFeaturesNV =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV,
+  ePipelineViewportExclusiveScissorStateCreateInfoNV =
+      VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV,
+  ePhysicalDeviceExclusiveScissorFeaturesNV =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV,
+  eCheckpointDataNV = VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV,
+  eQueueFamilyCheckpointPropertiesNV =
+      VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV,
+  ePhysicalDeviceShaderIntegerFunctions2FeaturesINTEL =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL,
+  eQueryPoolPerformanceQueryCreateInfoINTEL =
+      VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL,
+  eInitializePerformanceApiInfoINTEL =
+      VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL,
+  ePerformanceMarkerInfoINTEL = VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL,
+  ePerformanceStreamMarkerInfoINTEL =
+      VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL,
+  ePerformanceOverrideInfoINTEL =
+      VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL,
+  ePerformanceConfigurationAcquireInfoINTEL =
+      VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL,
+  ePhysicalDevicePciBusInfoPropertiesEXT =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT,
+  eDisplayNativeHdrSurfaceCapabilitiesAMD =
+      VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD,
+  eSwapchainDisplayNativeHdrCreateInfoAMD =
+      VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD,
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+  eImagepipeSurfaceCreateInfoFUCHSIA =
+      VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA,
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
-    , ePhysicalDeviceShaderTerminateInvocationFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR
-#if defined( VK_USE_PLATFORM_METAL_EXT )
-    , eMetalSurfaceCreateInfoEXT = VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT
+  ePhysicalDeviceShaderTerminateInvocationFeaturesKHR =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR,
+#if defined(VK_USE_PLATFORM_METAL_EXT)
+  eMetalSurfaceCreateInfoEXT = VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT,
 #endif /*VK_USE_PLATFORM_METAL_EXT*/
-    , ePhysicalDeviceFragmentDensityMapFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT
-    , ePhysicalDeviceFragmentDensityMapPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT
-    , eRenderPassFragmentDensityMapCreateInfoEXT = VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT
-    , ePhysicalDeviceSubgroupSizeControlPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT
-    , ePipelineShaderStageRequiredSubgroupSizeCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT
-    , ePhysicalDeviceSubgroupSizeControlFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT
-    , eFragmentShadingRateAttachmentInfoKHR = VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR
-    , ePipelineFragmentShadingRateStateCreateInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR
-    , ePhysicalDeviceFragmentShadingRatePropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR
-    , ePhysicalDeviceFragmentShadingRateFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR
-    , ePhysicalDeviceFragmentShadingRateKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR
-    , ePhysicalDeviceShaderCoreProperties2AMD = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD
-    , ePhysicalDeviceCoherentMemoryFeaturesAMD = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD
-    , ePhysicalDeviceShaderImageAtomicInt64FeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT
-    , ePhysicalDeviceMemoryBudgetPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT
-    , ePhysicalDeviceMemoryPriorityFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT
-    , eMemoryPriorityAllocateInfoEXT = VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT
-    , eSurfaceProtectedCapabilitiesKHR = VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR
-    , ePhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV
-    , ePhysicalDeviceBufferDeviceAddressFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT
-    , eBufferDeviceAddressCreateInfoEXT = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT
-    , ePhysicalDeviceToolPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT
-    , eValidationFeaturesEXT = VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT
-    , ePhysicalDeviceCooperativeMatrixFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV
-    , eCooperativeMatrixPropertiesNV = VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV
-    , ePhysicalDeviceCooperativeMatrixPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV
-    , ePhysicalDeviceCoverageReductionModeFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV
-    , ePipelineCoverageReductionStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV
-    , eFramebufferMixedSamplesCombinationNV = VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV
-    , ePhysicalDeviceFragmentShaderInterlockFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT
-    , ePhysicalDeviceYcbcrImageArraysFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT
-#if defined( VK_USE_PLATFORM_WIN32_KHR )
-    , eSurfaceFullScreenExclusiveInfoEXT = VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT
-    , eSurfaceCapabilitiesFullScreenExclusiveEXT = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT
-    , eSurfaceFullScreenExclusiveWin32InfoEXT = VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT
+  ePhysicalDeviceFragmentDensityMapFeaturesEXT =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT,
+  ePhysicalDeviceFragmentDensityMapPropertiesEXT =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT,
+  eRenderPassFragmentDensityMapCreateInfoEXT =
+      VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT,
+  ePhysicalDeviceSubgroupSizeControlPropertiesEXT =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT,
+  ePipelineShaderStageRequiredSubgroupSizeCreateInfoEXT =
+      VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT,
+  ePhysicalDeviceSubgroupSizeControlFeaturesEXT =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT,
+  eFragmentShadingRateAttachmentInfoKHR =
+      VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR,
+  ePipelineFragmentShadingRateStateCreateInfoKHR =
+      VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR,
+  ePhysicalDeviceFragmentShadingRatePropertiesKHR =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR,
+  ePhysicalDeviceFragmentShadingRateFeaturesKHR =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR,
+  ePhysicalDeviceFragmentShadingRateKHR =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR,
+  ePhysicalDeviceShaderCoreProperties2AMD =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD,
+  ePhysicalDeviceCoherentMemoryFeaturesAMD =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD,
+  ePhysicalDeviceShaderImageAtomicInt64FeaturesEXT =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT,
+  ePhysicalDeviceMemoryBudgetPropertiesEXT =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT,
+  ePhysicalDeviceMemoryPriorityFeaturesEXT =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT,
+  eMemoryPriorityAllocateInfoEXT =
+      VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT,
+  eSurfaceProtectedCapabilitiesKHR =
+      VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR,
+  ePhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV,
+  ePhysicalDeviceBufferDeviceAddressFeaturesEXT =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT,
+  eBufferDeviceAddressCreateInfoEXT =
+      VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT,
+  ePhysicalDeviceToolPropertiesEXT =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT,
+  eValidationFeaturesEXT = VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT,
+  ePhysicalDeviceCooperativeMatrixFeaturesNV =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV,
+  eCooperativeMatrixPropertiesNV =
+      VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV,
+  ePhysicalDeviceCooperativeMatrixPropertiesNV =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV,
+  ePhysicalDeviceCoverageReductionModeFeaturesNV =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV,
+  ePipelineCoverageReductionStateCreateInfoNV =
+      VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV,
+  eFramebufferMixedSamplesCombinationNV =
+      VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV,
+  ePhysicalDeviceFragmentShaderInterlockFeaturesEXT =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT,
+  ePhysicalDeviceYcbcrImageArraysFeaturesEXT =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT,
+#if defined(VK_USE_PLATFORM_WIN32_KHR)
+  eSurfaceFullScreenExclusiveInfoEXT =
+      VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT,
+  eSurfaceCapabilitiesFullScreenExclusiveEXT =
+      VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT,
+  eSurfaceFullScreenExclusiveWin32InfoEXT =
+      VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT,
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
-    , eHeadlessSurfaceCreateInfoEXT = VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT
-    , ePhysicalDeviceLineRasterizationFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT
-    , ePipelineRasterizationLineStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT
-    , ePhysicalDeviceLineRasterizationPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT
-    , ePhysicalDeviceShaderAtomicFloatFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT
-    , ePhysicalDeviceIndexTypeUint8FeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT
-    , ePhysicalDeviceExtendedDynamicStateFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT
-    , ePhysicalDevicePipelineExecutablePropertiesFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR
-    , ePipelineInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR
-    , ePipelineExecutablePropertiesKHR = VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR
-    , ePipelineExecutableInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR
-    , ePipelineExecutableStatisticKHR = VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR
-    , ePipelineExecutableInternalRepresentationKHR = VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR
-    , ePhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT
-    , ePhysicalDeviceDeviceGeneratedCommandsPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV
-    , eGraphicsShaderGroupCreateInfoNV = VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV
-    , eGraphicsPipelineShaderGroupsCreateInfoNV = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV
-    , eIndirectCommandsLayoutTokenNV = VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV
-    , eIndirectCommandsLayoutCreateInfoNV = VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV
-    , eGeneratedCommandsInfoNV = VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV
-    , eGeneratedCommandsMemoryRequirementsInfoNV = VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV
-    , ePhysicalDeviceDeviceGeneratedCommandsFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV
-    , ePhysicalDeviceTexelBufferAlignmentFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT
-    , ePhysicalDeviceTexelBufferAlignmentPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT
-    , eCommandBufferInheritanceRenderPassTransformInfoQCOM = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM
-    , eRenderPassTransformBeginInfoQCOM = VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM
-    , ePhysicalDeviceDeviceMemoryReportFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT
-    , eDeviceDeviceMemoryReportCreateInfoEXT = VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT
-    , eDeviceMemoryReportCallbackDataEXT = VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT
-    , ePhysicalDeviceRobustness2FeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT
-    , ePhysicalDeviceRobustness2PropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT
-    , eSamplerCustomBorderColorCreateInfoEXT = VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT
-    , ePhysicalDeviceCustomBorderColorPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT
-    , ePhysicalDeviceCustomBorderColorFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT
-    , ePipelineLibraryCreateInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR
-    , ePhysicalDevicePrivateDataFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT
-    , eDevicePrivateDataCreateInfoEXT = VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT
-    , ePrivateDataSlotCreateInfoEXT = VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO_EXT
-    , ePhysicalDevicePipelineCreationCacheControlFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT
-    , ePhysicalDeviceDiagnosticsConfigFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV
-    , eDeviceDiagnosticsConfigCreateInfoNV = VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV
-    , eMemoryBarrier2KHR = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR
-    , eBufferMemoryBarrier2KHR = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2_KHR
-    , eImageMemoryBarrier2KHR = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2_KHR
-    , eDependencyInfoKHR = VK_STRUCTURE_TYPE_DEPENDENCY_INFO_KHR
-    , eSubmitInfo2KHR = VK_STRUCTURE_TYPE_SUBMIT_INFO_2_KHR
-    , eSemaphoreSubmitInfoKHR = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO_KHR
-    , eCommandBufferSubmitInfoKHR = VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO_KHR
-    , ePhysicalDeviceSynchronization2FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR
-    , eQueueFamilyCheckpointProperties2Nv = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV
-    , eCheckpointData2Nv = VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV
-#if defined( VK_USE_PLATFORM_FUCHSIA )
-    , eBufferCollectionCreateInfoFUCHSIA = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA
-    , eImportMemoryBufferCollectionFUCHSIA = VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA
-    , eBufferCollectionImageCreateInfoFUCHSIA = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA
-    , eBufferCollectionPropertiesFUCHSIA = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA
-    , eBufferConstraintsInfoFUCHSIA = VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA
-    , eBufferCollectionBufferCreateInfoFUCHSIA = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA
-    , eImageConstraintsInfoFUCHSIA = VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA
-    , eImageFormatConstraintsInfoFUCHSIA = VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA
-    , eBufferCollectionProperties2FUCHSIA = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES2_FUCHSIA
-    , eSysmemColorSpaceFUCHSIA = VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA
+  eHeadlessSurfaceCreateInfoEXT =
+      VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT,
+  ePhysicalDeviceLineRasterizationFeaturesEXT =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT,
+  ePipelineRasterizationLineStateCreateInfoEXT =
+      VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT,
+  ePhysicalDeviceLineRasterizationPropertiesEXT =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT,
+  ePhysicalDeviceShaderAtomicFloatFeaturesEXT =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT,
+  ePhysicalDeviceIndexTypeUint8FeaturesEXT =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT,
+  ePhysicalDeviceExtendedDynamicStateFeaturesEXT =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT,
+  ePhysicalDevicePipelineExecutablePropertiesFeaturesKHR =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR,
+  ePipelineInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR,
+  ePipelineExecutablePropertiesKHR =
+      VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR,
+  ePipelineExecutableInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR,
+  ePipelineExecutableStatisticKHR =
+      VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR,
+  ePipelineExecutableInternalRepresentationKHR =
+      VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR,
+  ePhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT,
+  ePhysicalDeviceDeviceGeneratedCommandsPropertiesNV =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV,
+  eGraphicsShaderGroupCreateInfoNV =
+      VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV,
+  eGraphicsPipelineShaderGroupsCreateInfoNV =
+      VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV,
+  eIndirectCommandsLayoutTokenNV =
+      VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV,
+  eIndirectCommandsLayoutCreateInfoNV =
+      VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV,
+  eGeneratedCommandsInfoNV = VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV,
+  eGeneratedCommandsMemoryRequirementsInfoNV =
+      VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV,
+  ePhysicalDeviceDeviceGeneratedCommandsFeaturesNV =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV,
+  ePhysicalDeviceTexelBufferAlignmentFeaturesEXT =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT,
+  ePhysicalDeviceTexelBufferAlignmentPropertiesEXT =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT,
+  eCommandBufferInheritanceRenderPassTransformInfoQCOM =
+      VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM,
+  eRenderPassTransformBeginInfoQCOM =
+      VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM,
+  ePhysicalDeviceDeviceMemoryReportFeaturesEXT =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT,
+  eDeviceDeviceMemoryReportCreateInfoEXT =
+      VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT,
+  eDeviceMemoryReportCallbackDataEXT =
+      VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT,
+  ePhysicalDeviceRobustness2FeaturesEXT =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT,
+  ePhysicalDeviceRobustness2PropertiesEXT =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT,
+  eSamplerCustomBorderColorCreateInfoEXT =
+      VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT,
+  ePhysicalDeviceCustomBorderColorPropertiesEXT =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT,
+  ePhysicalDeviceCustomBorderColorFeaturesEXT =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT,
+  ePipelineLibraryCreateInfoKHR =
+      VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR,
+  ePhysicalDevicePrivateDataFeaturesEXT =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT,
+  eDevicePrivateDataCreateInfoEXT =
+      VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT,
+  ePrivateDataSlotCreateInfoEXT =
+      VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO_EXT,
+  ePhysicalDevicePipelineCreationCacheControlFeaturesEXT =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT,
+  ePhysicalDeviceDiagnosticsConfigFeaturesNV =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV,
+  eDeviceDiagnosticsConfigCreateInfoNV =
+      VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV,
+  eMemoryBarrier2KHR = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR,
+  eBufferMemoryBarrier2KHR = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2_KHR,
+  eImageMemoryBarrier2KHR = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2_KHR,
+  eDependencyInfoKHR = VK_STRUCTURE_TYPE_DEPENDENCY_INFO_KHR,
+  eSubmitInfo2KHR = VK_STRUCTURE_TYPE_SUBMIT_INFO_2_KHR,
+  eSemaphoreSubmitInfoKHR = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO_KHR,
+  eCommandBufferSubmitInfoKHR =
+      VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO_KHR,
+  ePhysicalDeviceSynchronization2FeaturesKHR =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR,
+  eQueueFamilyCheckpointProperties2Nv =
+      VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV,
+  eCheckpointData2Nv = VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV,
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+  eBufferCollectionCreateInfoFUCHSIA =
+      VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA,
+  eImportMemoryBufferCollectionFUCHSIA =
+      VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA,
+  eBufferCollectionImageCreateInfoFUCHSIA =
+      VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA,
+  eBufferCollectionPropertiesFUCHSIA =
+      VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA,
+  eBufferConstraintsInfoFUCHSIA =
+      VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA,
+  eBufferCollectionBufferCreateInfoFUCHSIA =
+      VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA,
+  eImageConstraintsInfoFUCHSIA =
+      VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA,
+  eImageFormatConstraintsInfoFUCHSIA =
+      VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA,
+  eBufferCollectionProperties2FUCHSIA =
+      VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES2_FUCHSIA,
+  eSysmemColorSpaceFUCHSIA = VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA,
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
-    , ePhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR
-    , ePhysicalDeviceFragmentShadingRateEnumsPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV
-    , ePhysicalDeviceFragmentShadingRateEnumsFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV
-    , ePipelineFragmentShadingRateEnumStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV
-    , ePhysicalDeviceFragmentDensityMap2FeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT
-    , ePhysicalDeviceFragmentDensityMap2PropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT
-    , eCopyCommandTransformInfoQCOM = VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM
-    , ePhysicalDeviceImageRobustnessFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT
-    , ePhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR
-    , eCopyBufferInfo2KHR = VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2_KHR
-    , eCopyImageInfo2KHR = VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2_KHR
-    , eCopyBufferToImageInfo2KHR = VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2_KHR
-    , eCopyImageToBufferInfo2KHR = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2_KHR
-    , eBlitImageInfo2KHR = VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2_KHR
-    , eResolveImageInfo2KHR = VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2_KHR
-    , eBufferCopy2KHR = VK_STRUCTURE_TYPE_BUFFER_COPY_2_KHR
-    , eImageCopy2KHR = VK_STRUCTURE_TYPE_IMAGE_COPY_2_KHR
-    , eImageBlit2KHR = VK_STRUCTURE_TYPE_IMAGE_BLIT_2_KHR
-    , eBufferImageCopy2KHR = VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2_KHR
-    , eImageResolve2KHR = VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR
-    , ePhysicalDevice4444FormatsFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT
-#if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
-    , eDirectfbSurfaceCreateInfoEXT = VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT
+  ePhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR,
+  ePhysicalDeviceFragmentShadingRateEnumsPropertiesNV =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV,
+  ePhysicalDeviceFragmentShadingRateEnumsFeaturesNV =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV,
+  ePipelineFragmentShadingRateEnumStateCreateInfoNV =
+      VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV,
+  ePhysicalDeviceFragmentDensityMap2FeaturesEXT =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT,
+  ePhysicalDeviceFragmentDensityMap2PropertiesEXT =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT,
+  eCopyCommandTransformInfoQCOM =
+      VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM,
+  ePhysicalDeviceImageRobustnessFeaturesEXT =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT,
+  ePhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR,
+  eCopyBufferInfo2KHR = VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2_KHR,
+  eCopyImageInfo2KHR = VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2_KHR,
+  eCopyBufferToImageInfo2KHR =
+      VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2_KHR,
+  eCopyImageToBufferInfo2KHR =
+      VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2_KHR,
+  eBlitImageInfo2KHR = VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2_KHR,
+  eResolveImageInfo2KHR = VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2_KHR,
+  eBufferCopy2KHR = VK_STRUCTURE_TYPE_BUFFER_COPY_2_KHR,
+  eImageCopy2KHR = VK_STRUCTURE_TYPE_IMAGE_COPY_2_KHR,
+  eImageBlit2KHR = VK_STRUCTURE_TYPE_IMAGE_BLIT_2_KHR,
+  eBufferImageCopy2KHR = VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2_KHR,
+  eImageResolve2KHR = VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR,
+  ePhysicalDevice4444FormatsFeaturesEXT =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT,
+#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
+  eDirectfbSurfaceCreateInfoEXT =
+      VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT,
 #endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
-    , ePhysicalDeviceMutableDescriptorTypeFeaturesVALVE = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE
-    , eMutableDescriptorTypeCreateInfoVALVE = VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE
-#if defined( VK_USE_PLATFORM_FUCHSIA )
-    , ePhysicalDeviceMemoryControlPropertiesFUCHSIA = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_CONTROL_PROPERTIES_FUCHSIA
-    , eMemoryRangeFUCHSIA = VK_STRUCTURE_TYPE_MEMORY_RANGE_FUCHSIA
-    , eMemoryOpResultFUCHSIA = VK_STRUCTURE_TYPE_MEMORY_OP_RESULT_FUCHSIA
-    , eControlOpsMemoryAllocateInfoFUCHSIA = VK_STRUCTURE_TYPE_CONTROL_OPS_MEMORY_ALLOCATE_INFO_FUCHSIA
-    , eImportMemoryZirconHandleInfoFUCHSIA = VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA
-    , eMemoryZirconHandlePropertiesFUCHSIA = VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA
-    , eMemoryGetZirconHandleInfoFUCHSIA = VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA
-    , eImportSemaphoreZirconHandleInfoFUCHSIA = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA
-    , eSemaphoreGetZirconHandleInfoFUCHSIA = VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA
+  ePhysicalDeviceMutableDescriptorTypeFeaturesVALVE =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE,
+  eMutableDescriptorTypeCreateInfoVALVE =
+      VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE,
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+  ePhysicalDeviceMemoryControlPropertiesFUCHSIA =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_CONTROL_PROPERTIES_FUCHSIA,
+  eMemoryRangeFUCHSIA = VK_STRUCTURE_TYPE_MEMORY_RANGE_FUCHSIA,
+  eMemoryOpResultFUCHSIA = VK_STRUCTURE_TYPE_MEMORY_OP_RESULT_FUCHSIA,
+  eControlOpsMemoryAllocateInfoFUCHSIA =
+      VK_STRUCTURE_TYPE_CONTROL_OPS_MEMORY_ALLOCATE_INFO_FUCHSIA,
+  eImportMemoryZirconHandleInfoFUCHSIA =
+      VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA,
+  eMemoryZirconHandlePropertiesFUCHSIA =
+      VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA,
+  eMemoryGetZirconHandleInfoFUCHSIA =
+      VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA,
+  eImportSemaphoreZirconHandleInfoFUCHSIA =
+      VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA,
+  eSemaphoreGetZirconHandleInfoFUCHSIA =
+      VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA,
+  eBufferCollectionCreateInfoFuchsiax =
+      VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIAX,
+  eImportMemoryBufferCollectionFuchsiax =
+      VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIAX,
+  eBufferCollectionImageCreateInfoFuchsiax =
+      VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIAX,
+  eBufferCollectionPropertiesFuchsiax =
+      VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIAX,
+  eBufferConstraintsInfoFuchsiax =
+      VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIAX,
+  eBufferCollectionBufferCreateInfoFuchsiax =
+      VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIAX,
+  eImageConstraintsInfoFuchsiax =
+      VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIAX,
+  eImageFormatConstraintsInfoFuchsiax =
+      VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIAX,
+  eBufferCollectionProperties2Fuchsiax =
+      VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES2_FUCHSIAX,
+  eSysmemColorSpaceFuchsiax = VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIAX,
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
-#if defined( VK_USE_PLATFORM_SCREEN_QNX )
-    , eScreenSurfaceCreateInfoQNX = VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX
+#if defined(VK_USE_PLATFORM_SCREEN_QNX)
+  eScreenSurfaceCreateInfoQNX =
+      VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX,
 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
-    , eAttachmentDescription2KHR = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR
-    , eAttachmentDescriptionStencilLayoutKHR = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR
-    , eAttachmentReference2KHR = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR
-    , eAttachmentReferenceStencilLayoutKHR = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR
-    , eBindBufferMemoryDeviceGroupInfoKHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHR
-    , eBindBufferMemoryInfoKHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR
-    , eBindImageMemoryDeviceGroupInfoKHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHR
-    , eBindImageMemoryInfoKHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR
-    , eBindImagePlaneMemoryInfoKHR = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR
-    , eBufferDeviceAddressInfoEXT = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT
-    , eBufferDeviceAddressInfoKHR = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR
-    , eBufferMemoryRequirementsInfo2KHR = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR
-    , eBufferOpaqueCaptureAddressCreateInfoKHR = VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR
-    , eDebugReportCreateInfoEXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT
-    , eDescriptorSetLayoutBindingFlagsCreateInfoEXT = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT
-    , eDescriptorSetLayoutSupportKHR = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR
-    , eDescriptorSetVariableDescriptorCountAllocateInfoEXT = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT
-    , eDescriptorSetVariableDescriptorCountLayoutSupportEXT = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT
-    , eDescriptorUpdateTemplateCreateInfoKHR = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR
-    , eDeviceGroupBindSparseInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHR
-    , eDeviceGroupCommandBufferBeginInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHR
-    , eDeviceGroupDeviceCreateInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHR
-    , eDeviceGroupRenderPassBeginInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHR
-    , eDeviceGroupSubmitInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHR
-    , eDeviceMemoryOpaqueCaptureAddressInfoKHR = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR
-    , eExportFenceCreateInfoKHR = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR
-    , eExportMemoryAllocateInfoKHR = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR
-    , eExportSemaphoreCreateInfoKHR = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR
-    , eExternalBufferPropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR
-    , eExternalFencePropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR
-    , eExternalImageFormatPropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR
-    , eExternalMemoryBufferCreateInfoKHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR
-    , eExternalMemoryImageCreateInfoKHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR
-    , eExternalSemaphorePropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR
-    , eFormatProperties2KHR = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR
-    , eFramebufferAttachmentsCreateInfoKHR = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO_KHR
-    , eFramebufferAttachmentImageInfoKHR = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO_KHR
-    , eImageFormatListCreateInfoKHR = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR
-    , eImageFormatProperties2KHR = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR
-    , eImageMemoryRequirementsInfo2KHR = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR
-    , eImagePlaneMemoryRequirementsInfoKHR = VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR
-    , eImageSparseMemoryRequirementsInfo2KHR = VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR
-    , eImageStencilUsageCreateInfoEXT = VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO_EXT
-    , eImageViewUsageCreateInfoKHR = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR
-    , eMemoryAllocateFlagsInfoKHR = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHR
-    , eMemoryDedicatedAllocateInfoKHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR
-    , eMemoryDedicatedRequirementsKHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR
-    , eMemoryOpaqueCaptureAddressAllocateInfoKHR = VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR
-    , eMemoryRequirements2KHR = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR
-    , ePhysicalDevice16BitStorageFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR
-    , ePhysicalDevice8BitStorageFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR
-    , ePhysicalDeviceBufferAddressFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT
-    , ePhysicalDeviceBufferDeviceAddressFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR
-    , ePhysicalDeviceDepthStencilResolvePropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR
-    , ePhysicalDeviceDescriptorIndexingFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT
-    , ePhysicalDeviceDescriptorIndexingPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT
-    , ePhysicalDeviceDriverPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR
-    , ePhysicalDeviceExternalBufferInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR
-    , ePhysicalDeviceExternalFenceInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR
-    , ePhysicalDeviceExternalImageFormatInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR
-    , ePhysicalDeviceExternalSemaphoreInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR
-    , ePhysicalDeviceFeatures2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR
-    , ePhysicalDeviceFloat16Int8FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR
-    , ePhysicalDeviceFloatControlsPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR
-    , ePhysicalDeviceGroupPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHR
-    , ePhysicalDeviceHostQueryResetFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT
-    , ePhysicalDeviceIdPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR
-    , ePhysicalDeviceImagelessFramebufferFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR
-    , ePhysicalDeviceImageFormatInfo2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR
-    , ePhysicalDeviceMaintenance3PropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR
-    , ePhysicalDeviceMemoryProperties2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR
-    , ePhysicalDeviceMultiviewFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR
-    , ePhysicalDeviceMultiviewPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR
-    , ePhysicalDevicePointClippingPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR
-    , ePhysicalDeviceProperties2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR
-    , ePhysicalDeviceSamplerFilterMinmaxPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT
-    , ePhysicalDeviceSamplerYcbcrConversionFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR
-    , ePhysicalDeviceScalarBlockLayoutFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT
-    , ePhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES_KHR
-    , ePhysicalDeviceShaderAtomicInt64FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR
-    , ePhysicalDeviceShaderDrawParameterFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES
-    , ePhysicalDeviceShaderFloat16Int8FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR
-    , ePhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES_KHR
-    , ePhysicalDeviceSparseImageFormatInfo2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR
-    , ePhysicalDeviceTimelineSemaphoreFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR
-    , ePhysicalDeviceTimelineSemaphorePropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR
-    , ePhysicalDeviceUniformBufferStandardLayoutFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR
-    , ePhysicalDeviceVariablePointersFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR
-    , ePhysicalDeviceVariablePointerFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES
-    , ePhysicalDeviceVariablePointerFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR
-    , ePhysicalDeviceVulkanMemoryModelFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR
-    , ePipelineTessellationDomainOriginStateCreateInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR
-    , eQueryPoolCreateInfoINTEL = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO_INTEL
-    , eQueueFamilyProperties2KHR = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR
-    , eRenderPassAttachmentBeginInfoKHR = VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO_KHR
-    , eRenderPassCreateInfo2KHR = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2_KHR
-    , eRenderPassInputAttachmentAspectCreateInfoKHR = VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR
-    , eRenderPassMultiviewCreateInfoKHR = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR
-    , eSamplerReductionModeCreateInfoEXT = VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT
-    , eSamplerYcbcrConversionCreateInfoKHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR
-    , eSamplerYcbcrConversionImageFormatPropertiesKHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR
-    , eSamplerYcbcrConversionInfoKHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR
-    , eSemaphoreSignalInfoKHR = VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO_KHR
-    , eSemaphoreTypeCreateInfoKHR = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO_KHR
-    , eSemaphoreWaitInfoKHR = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO_KHR
-    , eSparseImageFormatProperties2KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR
-    , eSparseImageMemoryRequirements2KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR
-    , eSubpassBeginInfoKHR = VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO_KHR
-    , eSubpassDependency2KHR = VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2_KHR
-    , eSubpassDescription2KHR = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2_KHR
-    , eSubpassDescriptionDepthStencilResolveKHR = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR
-    , eSubpassEndInfoKHR = VK_STRUCTURE_TYPE_SUBPASS_END_INFO_KHR
-    , eTimelineSemaphoreSubmitInfoKHR = VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO_KHR
-  // clang-format on
+  eAttachmentDescription2KHR = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR,
+  eAttachmentDescriptionStencilLayoutKHR =
+      VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR,
+  eAttachmentReference2KHR = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR,
+  eAttachmentReferenceStencilLayoutKHR =
+      VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR,
+  eBindBufferMemoryDeviceGroupInfoKHR =
+      VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHR,
+  eBindBufferMemoryInfoKHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR,
+  eBindImageMemoryDeviceGroupInfoKHR =
+      VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHR,
+  eBindImageMemoryInfoKHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR,
+  eBindImagePlaneMemoryInfoKHR =
+      VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR,
+  eBufferDeviceAddressInfoEXT =
+      VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT,
+  eBufferDeviceAddressInfoKHR =
+      VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR,
+  eBufferMemoryRequirementsInfo2KHR =
+      VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR,
+  eBufferOpaqueCaptureAddressCreateInfoKHR =
+      VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR,
+  eDebugReportCreateInfoEXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT,
+  eDescriptorSetLayoutBindingFlagsCreateInfoEXT =
+      VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT,
+  eDescriptorSetLayoutSupportKHR =
+      VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR,
+  eDescriptorSetVariableDescriptorCountAllocateInfoEXT =
+      VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT,
+  eDescriptorSetVariableDescriptorCountLayoutSupportEXT =
+      VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT,
+  eDescriptorUpdateTemplateCreateInfoKHR =
+      VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR,
+  eDeviceGroupBindSparseInfoKHR =
+      VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHR,
+  eDeviceGroupCommandBufferBeginInfoKHR =
+      VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHR,
+  eDeviceGroupDeviceCreateInfoKHR =
+      VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHR,
+  eDeviceGroupRenderPassBeginInfoKHR =
+      VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHR,
+  eDeviceGroupSubmitInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHR,
+  eDeviceMemoryOpaqueCaptureAddressInfoKHR =
+      VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR,
+  eExportFenceCreateInfoKHR = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR,
+  eExportMemoryAllocateInfoKHR =
+      VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR,
+  eExportSemaphoreCreateInfoKHR =
+      VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR,
+  eExternalBufferPropertiesKHR =
+      VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR,
+  eExternalFencePropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR,
+  eExternalImageFormatPropertiesKHR =
+      VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR,
+  eExternalMemoryBufferCreateInfoKHR =
+      VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR,
+  eExternalMemoryImageCreateInfoKHR =
+      VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR,
+  eExternalSemaphorePropertiesKHR =
+      VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR,
+  eFormatProperties2KHR = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR,
+  eFramebufferAttachmentsCreateInfoKHR =
+      VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO_KHR,
+  eFramebufferAttachmentImageInfoKHR =
+      VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO_KHR,
+  eImageFormatListCreateInfoKHR =
+      VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR,
+  eImageFormatProperties2KHR = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR,
+  eImageMemoryRequirementsInfo2KHR =
+      VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR,
+  eImagePlaneMemoryRequirementsInfoKHR =
+      VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR,
+  eImageSparseMemoryRequirementsInfo2KHR =
+      VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR,
+  eImageStencilUsageCreateInfoEXT =
+      VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO_EXT,
+  eImageViewUsageCreateInfoKHR =
+      VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR,
+  eMemoryAllocateFlagsInfoKHR =
+      VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHR,
+  eMemoryDedicatedAllocateInfoKHR =
+      VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR,
+  eMemoryDedicatedRequirementsKHR =
+      VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR,
+  eMemoryOpaqueCaptureAddressAllocateInfoKHR =
+      VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR,
+  eMemoryRequirements2KHR = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR,
+  ePhysicalDevice16BitStorageFeaturesKHR =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR,
+  ePhysicalDevice8BitStorageFeaturesKHR =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR,
+  ePhysicalDeviceBufferAddressFeaturesEXT =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT,
+  ePhysicalDeviceBufferDeviceAddressFeaturesKHR =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR,
+  ePhysicalDeviceDepthStencilResolvePropertiesKHR =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR,
+  ePhysicalDeviceDescriptorIndexingFeaturesEXT =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT,
+  ePhysicalDeviceDescriptorIndexingPropertiesEXT =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT,
+  ePhysicalDeviceDriverPropertiesKHR =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR,
+  ePhysicalDeviceExternalBufferInfoKHR =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR,
+  ePhysicalDeviceExternalFenceInfoKHR =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR,
+  ePhysicalDeviceExternalImageFormatInfoKHR =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR,
+  ePhysicalDeviceExternalSemaphoreInfoKHR =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR,
+  ePhysicalDeviceFeatures2KHR =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR,
+  ePhysicalDeviceFloat16Int8FeaturesKHR =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR,
+  ePhysicalDeviceFloatControlsPropertiesKHR =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR,
+  ePhysicalDeviceGroupPropertiesKHR =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHR,
+  ePhysicalDeviceHostQueryResetFeaturesEXT =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT,
+  ePhysicalDeviceIdPropertiesKHR =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR,
+  ePhysicalDeviceImagelessFramebufferFeaturesKHR =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR,
+  ePhysicalDeviceImageFormatInfo2KHR =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR,
+  ePhysicalDeviceMaintenance3PropertiesKHR =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR,
+  ePhysicalDeviceMemoryProperties2KHR =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR,
+  ePhysicalDeviceMultiviewFeaturesKHR =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR,
+  ePhysicalDeviceMultiviewPropertiesKHR =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR,
+  ePhysicalDevicePointClippingPropertiesKHR =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR,
+  ePhysicalDeviceProperties2KHR =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR,
+  ePhysicalDeviceSamplerFilterMinmaxPropertiesEXT =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT,
+  ePhysicalDeviceSamplerYcbcrConversionFeaturesKHR =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR,
+  ePhysicalDeviceScalarBlockLayoutFeaturesEXT =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT,
+  ePhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES_KHR,
+  ePhysicalDeviceShaderAtomicInt64FeaturesKHR =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR,
+  ePhysicalDeviceShaderDrawParameterFeatures =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES,
+  ePhysicalDeviceShaderFloat16Int8FeaturesKHR =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR,
+  ePhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES_KHR,
+  ePhysicalDeviceSparseImageFormatInfo2KHR =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR,
+  ePhysicalDeviceTimelineSemaphoreFeaturesKHR =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR,
+  ePhysicalDeviceTimelineSemaphorePropertiesKHR =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR,
+  ePhysicalDeviceUniformBufferStandardLayoutFeaturesKHR =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR,
+  ePhysicalDeviceVariablePointersFeaturesKHR =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR,
+  ePhysicalDeviceVariablePointerFeatures =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES,
+  ePhysicalDeviceVariablePointerFeaturesKHR =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR,
+  ePhysicalDeviceVulkanMemoryModelFeaturesKHR =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR,
+  ePipelineTessellationDomainOriginStateCreateInfoKHR =
+      VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR,
+  eQueryPoolCreateInfoINTEL = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO_INTEL,
+  eQueueFamilyProperties2KHR = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR,
+  eRenderPassAttachmentBeginInfoKHR =
+      VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO_KHR,
+  eRenderPassCreateInfo2KHR = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2_KHR,
+  eRenderPassInputAttachmentAspectCreateInfoKHR =
+      VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR,
+  eRenderPassMultiviewCreateInfoKHR =
+      VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR,
+  eSamplerReductionModeCreateInfoEXT =
+      VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT,
+  eSamplerYcbcrConversionCreateInfoKHR =
+      VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR,
+  eSamplerYcbcrConversionImageFormatPropertiesKHR =
+      VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR,
+  eSamplerYcbcrConversionInfoKHR =
+      VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR,
+  eSemaphoreSignalInfoKHR = VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO_KHR,
+  eSemaphoreTypeCreateInfoKHR =
+      VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO_KHR,
+  eSemaphoreWaitInfoKHR = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO_KHR,
+  eSparseImageFormatProperties2KHR =
+      VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR,
+  eSparseImageMemoryRequirements2KHR =
+      VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR,
+  eSubpassBeginInfoKHR = VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO_KHR,
+  eSubpassDependency2KHR = VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2_KHR,
+  eSubpassDescription2KHR = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2_KHR,
+  eSubpassDescriptionDepthStencilResolveKHR =
+      VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR,
+  eSubpassEndInfoKHR = VK_STRUCTURE_TYPE_SUBPASS_END_INFO_KHR,
+  eTimelineSemaphoreSubmitInfoKHR =
+      VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO_KHR
 };
 
 VULKAN_HPP_INLINE std::string to_string(StructureType value) {
@@ -12916,6 +7571,26 @@
     return "ImportSemaphoreZirconHandleInfoFUCHSIA";
   case StructureType::eSemaphoreGetZirconHandleInfoFUCHSIA:
     return "SemaphoreGetZirconHandleInfoFUCHSIA";
+  case StructureType::eBufferCollectionCreateInfoFuchsiax:
+    return "BufferCollectionCreateInfoFuchsiax";
+  case StructureType::eImportMemoryBufferCollectionFuchsiax:
+    return "ImportMemoryBufferCollectionFuchsiax";
+  case StructureType::eBufferCollectionImageCreateInfoFuchsiax:
+    return "BufferCollectionImageCreateInfoFuchsiax";
+  case StructureType::eBufferCollectionPropertiesFuchsiax:
+    return "BufferCollectionPropertiesFuchsiax";
+  case StructureType::eBufferConstraintsInfoFuchsiax:
+    return "BufferConstraintsInfoFuchsiax";
+  case StructureType::eBufferCollectionBufferCreateInfoFuchsiax:
+    return "BufferCollectionBufferCreateInfoFuchsiax";
+  case StructureType::eImageConstraintsInfoFuchsiax:
+    return "ImageConstraintsInfoFuchsiax";
+  case StructureType::eImageFormatConstraintsInfoFuchsiax:
+    return "ImageFormatConstraintsInfoFuchsiax";
+  case StructureType::eBufferCollectionProperties2Fuchsiax:
+    return "BufferCollectionProperties2Fuchsiax";
+  case StructureType::eSysmemColorSpaceFuchsiax:
+    return "SysmemColorSpaceFuchsiax";
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 #if defined(VK_USE_PLATFORM_SCREEN_QNX)
   case StructureType::eScreenSurfaceCreateInfoQNX:
@@ -12928,6 +7603,3616 @@
   }
 }
 
+enum class ObjectType {
+  eUnknown = VK_OBJECT_TYPE_UNKNOWN,
+  eInstance = VK_OBJECT_TYPE_INSTANCE,
+  ePhysicalDevice = VK_OBJECT_TYPE_PHYSICAL_DEVICE,
+  eDevice = VK_OBJECT_TYPE_DEVICE,
+  eQueue = VK_OBJECT_TYPE_QUEUE,
+  eSemaphore = VK_OBJECT_TYPE_SEMAPHORE,
+  eCommandBuffer = VK_OBJECT_TYPE_COMMAND_BUFFER,
+  eFence = VK_OBJECT_TYPE_FENCE,
+  eDeviceMemory = VK_OBJECT_TYPE_DEVICE_MEMORY,
+  eBuffer = VK_OBJECT_TYPE_BUFFER,
+  eImage = VK_OBJECT_TYPE_IMAGE,
+  eEvent = VK_OBJECT_TYPE_EVENT,
+  eQueryPool = VK_OBJECT_TYPE_QUERY_POOL,
+  eBufferView = VK_OBJECT_TYPE_BUFFER_VIEW,
+  eImageView = VK_OBJECT_TYPE_IMAGE_VIEW,
+  eShaderModule = VK_OBJECT_TYPE_SHADER_MODULE,
+  ePipelineCache = VK_OBJECT_TYPE_PIPELINE_CACHE,
+  ePipelineLayout = VK_OBJECT_TYPE_PIPELINE_LAYOUT,
+  eRenderPass = VK_OBJECT_TYPE_RENDER_PASS,
+  ePipeline = VK_OBJECT_TYPE_PIPELINE,
+  eDescriptorSetLayout = VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT,
+  eSampler = VK_OBJECT_TYPE_SAMPLER,
+  eDescriptorPool = VK_OBJECT_TYPE_DESCRIPTOR_POOL,
+  eDescriptorSet = VK_OBJECT_TYPE_DESCRIPTOR_SET,
+  eFramebuffer = VK_OBJECT_TYPE_FRAMEBUFFER,
+  eCommandPool = VK_OBJECT_TYPE_COMMAND_POOL,
+  eSamplerYcbcrConversion = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION,
+  eDescriptorUpdateTemplate = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE,
+  eSurfaceKHR = VK_OBJECT_TYPE_SURFACE_KHR,
+  eSwapchainKHR = VK_OBJECT_TYPE_SWAPCHAIN_KHR,
+  eDisplayKHR = VK_OBJECT_TYPE_DISPLAY_KHR,
+  eDisplayModeKHR = VK_OBJECT_TYPE_DISPLAY_MODE_KHR,
+  eDebugReportCallbackEXT = VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT,
+  eDebugUtilsMessengerEXT = VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT,
+  eAccelerationStructureKHR = VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR,
+  eValidationCacheEXT = VK_OBJECT_TYPE_VALIDATION_CACHE_EXT,
+  eAccelerationStructureNV = VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV,
+  ePerformanceConfigurationINTEL =
+      VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL,
+  eDeferredOperationKHR = VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR,
+  eIndirectCommandsLayoutNV = VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV,
+  ePrivateDataSlotEXT = VK_OBJECT_TYPE_PRIVATE_DATA_SLOT_EXT,
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+  eBufferCollectionFUCHSIA = VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA,
+  eBufferCollectionFuchsiax = VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIAX,
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+  eDescriptorUpdateTemplateKHR = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR,
+  eSamplerYcbcrConversionKHR = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR
+};
+
+VULKAN_HPP_INLINE std::string to_string(ObjectType value) {
+  switch (value) {
+  case ObjectType::eUnknown:
+    return "Unknown";
+  case ObjectType::eInstance:
+    return "Instance";
+  case ObjectType::ePhysicalDevice:
+    return "PhysicalDevice";
+  case ObjectType::eDevice:
+    return "Device";
+  case ObjectType::eQueue:
+    return "Queue";
+  case ObjectType::eSemaphore:
+    return "Semaphore";
+  case ObjectType::eCommandBuffer:
+    return "CommandBuffer";
+  case ObjectType::eFence:
+    return "Fence";
+  case ObjectType::eDeviceMemory:
+    return "DeviceMemory";
+  case ObjectType::eBuffer:
+    return "Buffer";
+  case ObjectType::eImage:
+    return "Image";
+  case ObjectType::eEvent:
+    return "Event";
+  case ObjectType::eQueryPool:
+    return "QueryPool";
+  case ObjectType::eBufferView:
+    return "BufferView";
+  case ObjectType::eImageView:
+    return "ImageView";
+  case ObjectType::eShaderModule:
+    return "ShaderModule";
+  case ObjectType::ePipelineCache:
+    return "PipelineCache";
+  case ObjectType::ePipelineLayout:
+    return "PipelineLayout";
+  case ObjectType::eRenderPass:
+    return "RenderPass";
+  case ObjectType::ePipeline:
+    return "Pipeline";
+  case ObjectType::eDescriptorSetLayout:
+    return "DescriptorSetLayout";
+  case ObjectType::eSampler:
+    return "Sampler";
+  case ObjectType::eDescriptorPool:
+    return "DescriptorPool";
+  case ObjectType::eDescriptorSet:
+    return "DescriptorSet";
+  case ObjectType::eFramebuffer:
+    return "Framebuffer";
+  case ObjectType::eCommandPool:
+    return "CommandPool";
+  case ObjectType::eSamplerYcbcrConversion:
+    return "SamplerYcbcrConversion";
+  case ObjectType::eDescriptorUpdateTemplate:
+    return "DescriptorUpdateTemplate";
+  case ObjectType::eSurfaceKHR:
+    return "SurfaceKHR";
+  case ObjectType::eSwapchainKHR:
+    return "SwapchainKHR";
+  case ObjectType::eDisplayKHR:
+    return "DisplayKHR";
+  case ObjectType::eDisplayModeKHR:
+    return "DisplayModeKHR";
+  case ObjectType::eDebugReportCallbackEXT:
+    return "DebugReportCallbackEXT";
+  case ObjectType::eDebugUtilsMessengerEXT:
+    return "DebugUtilsMessengerEXT";
+  case ObjectType::eAccelerationStructureKHR:
+    return "AccelerationStructureKHR";
+  case ObjectType::eValidationCacheEXT:
+    return "ValidationCacheEXT";
+  case ObjectType::eAccelerationStructureNV:
+    return "AccelerationStructureNV";
+  case ObjectType::ePerformanceConfigurationINTEL:
+    return "PerformanceConfigurationINTEL";
+  case ObjectType::eDeferredOperationKHR:
+    return "DeferredOperationKHR";
+  case ObjectType::eIndirectCommandsLayoutNV:
+    return "IndirectCommandsLayoutNV";
+  case ObjectType::ePrivateDataSlotEXT:
+    return "PrivateDataSlotEXT";
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+  case ObjectType::eBufferCollectionFUCHSIA:
+    return "BufferCollectionFUCHSIA";
+  case ObjectType::eBufferCollectionFuchsiax:
+    return "BufferCollectionFuchsiax";
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class VendorId {
+  eVIV = VK_VENDOR_ID_VIV,
+  eVSI = VK_VENDOR_ID_VSI,
+  eKazan = VK_VENDOR_ID_KAZAN,
+  eCodeplay = VK_VENDOR_ID_CODEPLAY,
+  eMESA = VK_VENDOR_ID_MESA,
+  ePocl = VK_VENDOR_ID_POCL
+};
+
+VULKAN_HPP_INLINE std::string to_string(VendorId value) {
+  switch (value) {
+  case VendorId::eVIV:
+    return "VIV";
+  case VendorId::eVSI:
+    return "VSI";
+  case VendorId::eKazan:
+    return "Kazan";
+  case VendorId::eCodeplay:
+    return "Codeplay";
+  case VendorId::eMESA:
+    return "MESA";
+  case VendorId::ePocl:
+    return "Pocl";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class PipelineCacheHeaderVersion {
+  eOne = VK_PIPELINE_CACHE_HEADER_VERSION_ONE
+};
+
+VULKAN_HPP_INLINE std::string to_string(PipelineCacheHeaderVersion value) {
+  switch (value) {
+  case PipelineCacheHeaderVersion::eOne:
+    return "One";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class Format {
+  eUndefined = VK_FORMAT_UNDEFINED,
+  eR4G4UnormPack8 = VK_FORMAT_R4G4_UNORM_PACK8,
+  eR4G4B4A4UnormPack16 = VK_FORMAT_R4G4B4A4_UNORM_PACK16,
+  eB4G4R4A4UnormPack16 = VK_FORMAT_B4G4R4A4_UNORM_PACK16,
+  eR5G6B5UnormPack16 = VK_FORMAT_R5G6B5_UNORM_PACK16,
+  eB5G6R5UnormPack16 = VK_FORMAT_B5G6R5_UNORM_PACK16,
+  eR5G5B5A1UnormPack16 = VK_FORMAT_R5G5B5A1_UNORM_PACK16,
+  eB5G5R5A1UnormPack16 = VK_FORMAT_B5G5R5A1_UNORM_PACK16,
+  eA1R5G5B5UnormPack16 = VK_FORMAT_A1R5G5B5_UNORM_PACK16,
+  eR8Unorm = VK_FORMAT_R8_UNORM,
+  eR8Snorm = VK_FORMAT_R8_SNORM,
+  eR8Uscaled = VK_FORMAT_R8_USCALED,
+  eR8Sscaled = VK_FORMAT_R8_SSCALED,
+  eR8Uint = VK_FORMAT_R8_UINT,
+  eR8Sint = VK_FORMAT_R8_SINT,
+  eR8Srgb = VK_FORMAT_R8_SRGB,
+  eR8G8Unorm = VK_FORMAT_R8G8_UNORM,
+  eR8G8Snorm = VK_FORMAT_R8G8_SNORM,
+  eR8G8Uscaled = VK_FORMAT_R8G8_USCALED,
+  eR8G8Sscaled = VK_FORMAT_R8G8_SSCALED,
+  eR8G8Uint = VK_FORMAT_R8G8_UINT,
+  eR8G8Sint = VK_FORMAT_R8G8_SINT,
+  eR8G8Srgb = VK_FORMAT_R8G8_SRGB,
+  eR8G8B8Unorm = VK_FORMAT_R8G8B8_UNORM,
+  eR8G8B8Snorm = VK_FORMAT_R8G8B8_SNORM,
+  eR8G8B8Uscaled = VK_FORMAT_R8G8B8_USCALED,
+  eR8G8B8Sscaled = VK_FORMAT_R8G8B8_SSCALED,
+  eR8G8B8Uint = VK_FORMAT_R8G8B8_UINT,
+  eR8G8B8Sint = VK_FORMAT_R8G8B8_SINT,
+  eR8G8B8Srgb = VK_FORMAT_R8G8B8_SRGB,
+  eB8G8R8Unorm = VK_FORMAT_B8G8R8_UNORM,
+  eB8G8R8Snorm = VK_FORMAT_B8G8R8_SNORM,
+  eB8G8R8Uscaled = VK_FORMAT_B8G8R8_USCALED,
+  eB8G8R8Sscaled = VK_FORMAT_B8G8R8_SSCALED,
+  eB8G8R8Uint = VK_FORMAT_B8G8R8_UINT,
+  eB8G8R8Sint = VK_FORMAT_B8G8R8_SINT,
+  eB8G8R8Srgb = VK_FORMAT_B8G8R8_SRGB,
+  eR8G8B8A8Unorm = VK_FORMAT_R8G8B8A8_UNORM,
+  eR8G8B8A8Snorm = VK_FORMAT_R8G8B8A8_SNORM,
+  eR8G8B8A8Uscaled = VK_FORMAT_R8G8B8A8_USCALED,
+  eR8G8B8A8Sscaled = VK_FORMAT_R8G8B8A8_SSCALED,
+  eR8G8B8A8Uint = VK_FORMAT_R8G8B8A8_UINT,
+  eR8G8B8A8Sint = VK_FORMAT_R8G8B8A8_SINT,
+  eR8G8B8A8Srgb = VK_FORMAT_R8G8B8A8_SRGB,
+  eB8G8R8A8Unorm = VK_FORMAT_B8G8R8A8_UNORM,
+  eB8G8R8A8Snorm = VK_FORMAT_B8G8R8A8_SNORM,
+  eB8G8R8A8Uscaled = VK_FORMAT_B8G8R8A8_USCALED,
+  eB8G8R8A8Sscaled = VK_FORMAT_B8G8R8A8_SSCALED,
+  eB8G8R8A8Uint = VK_FORMAT_B8G8R8A8_UINT,
+  eB8G8R8A8Sint = VK_FORMAT_B8G8R8A8_SINT,
+  eB8G8R8A8Srgb = VK_FORMAT_B8G8R8A8_SRGB,
+  eA8B8G8R8UnormPack32 = VK_FORMAT_A8B8G8R8_UNORM_PACK32,
+  eA8B8G8R8SnormPack32 = VK_FORMAT_A8B8G8R8_SNORM_PACK32,
+  eA8B8G8R8UscaledPack32 = VK_FORMAT_A8B8G8R8_USCALED_PACK32,
+  eA8B8G8R8SscaledPack32 = VK_FORMAT_A8B8G8R8_SSCALED_PACK32,
+  eA8B8G8R8UintPack32 = VK_FORMAT_A8B8G8R8_UINT_PACK32,
+  eA8B8G8R8SintPack32 = VK_FORMAT_A8B8G8R8_SINT_PACK32,
+  eA8B8G8R8SrgbPack32 = VK_FORMAT_A8B8G8R8_SRGB_PACK32,
+  eA2R10G10B10UnormPack32 = VK_FORMAT_A2R10G10B10_UNORM_PACK32,
+  eA2R10G10B10SnormPack32 = VK_FORMAT_A2R10G10B10_SNORM_PACK32,
+  eA2R10G10B10UscaledPack32 = VK_FORMAT_A2R10G10B10_USCALED_PACK32,
+  eA2R10G10B10SscaledPack32 = VK_FORMAT_A2R10G10B10_SSCALED_PACK32,
+  eA2R10G10B10UintPack32 = VK_FORMAT_A2R10G10B10_UINT_PACK32,
+  eA2R10G10B10SintPack32 = VK_FORMAT_A2R10G10B10_SINT_PACK32,
+  eA2B10G10R10UnormPack32 = VK_FORMAT_A2B10G10R10_UNORM_PACK32,
+  eA2B10G10R10SnormPack32 = VK_FORMAT_A2B10G10R10_SNORM_PACK32,
+  eA2B10G10R10UscaledPack32 = VK_FORMAT_A2B10G10R10_USCALED_PACK32,
+  eA2B10G10R10SscaledPack32 = VK_FORMAT_A2B10G10R10_SSCALED_PACK32,
+  eA2B10G10R10UintPack32 = VK_FORMAT_A2B10G10R10_UINT_PACK32,
+  eA2B10G10R10SintPack32 = VK_FORMAT_A2B10G10R10_SINT_PACK32,
+  eR16Unorm = VK_FORMAT_R16_UNORM,
+  eR16Snorm = VK_FORMAT_R16_SNORM,
+  eR16Uscaled = VK_FORMAT_R16_USCALED,
+  eR16Sscaled = VK_FORMAT_R16_SSCALED,
+  eR16Uint = VK_FORMAT_R16_UINT,
+  eR16Sint = VK_FORMAT_R16_SINT,
+  eR16Sfloat = VK_FORMAT_R16_SFLOAT,
+  eR16G16Unorm = VK_FORMAT_R16G16_UNORM,
+  eR16G16Snorm = VK_FORMAT_R16G16_SNORM,
+  eR16G16Uscaled = VK_FORMAT_R16G16_USCALED,
+  eR16G16Sscaled = VK_FORMAT_R16G16_SSCALED,
+  eR16G16Uint = VK_FORMAT_R16G16_UINT,
+  eR16G16Sint = VK_FORMAT_R16G16_SINT,
+  eR16G16Sfloat = VK_FORMAT_R16G16_SFLOAT,
+  eR16G16B16Unorm = VK_FORMAT_R16G16B16_UNORM,
+  eR16G16B16Snorm = VK_FORMAT_R16G16B16_SNORM,
+  eR16G16B16Uscaled = VK_FORMAT_R16G16B16_USCALED,
+  eR16G16B16Sscaled = VK_FORMAT_R16G16B16_SSCALED,
+  eR16G16B16Uint = VK_FORMAT_R16G16B16_UINT,
+  eR16G16B16Sint = VK_FORMAT_R16G16B16_SINT,
+  eR16G16B16Sfloat = VK_FORMAT_R16G16B16_SFLOAT,
+  eR16G16B16A16Unorm = VK_FORMAT_R16G16B16A16_UNORM,
+  eR16G16B16A16Snorm = VK_FORMAT_R16G16B16A16_SNORM,
+  eR16G16B16A16Uscaled = VK_FORMAT_R16G16B16A16_USCALED,
+  eR16G16B16A16Sscaled = VK_FORMAT_R16G16B16A16_SSCALED,
+  eR16G16B16A16Uint = VK_FORMAT_R16G16B16A16_UINT,
+  eR16G16B16A16Sint = VK_FORMAT_R16G16B16A16_SINT,
+  eR16G16B16A16Sfloat = VK_FORMAT_R16G16B16A16_SFLOAT,
+  eR32Uint = VK_FORMAT_R32_UINT,
+  eR32Sint = VK_FORMAT_R32_SINT,
+  eR32Sfloat = VK_FORMAT_R32_SFLOAT,
+  eR32G32Uint = VK_FORMAT_R32G32_UINT,
+  eR32G32Sint = VK_FORMAT_R32G32_SINT,
+  eR32G32Sfloat = VK_FORMAT_R32G32_SFLOAT,
+  eR32G32B32Uint = VK_FORMAT_R32G32B32_UINT,
+  eR32G32B32Sint = VK_FORMAT_R32G32B32_SINT,
+  eR32G32B32Sfloat = VK_FORMAT_R32G32B32_SFLOAT,
+  eR32G32B32A32Uint = VK_FORMAT_R32G32B32A32_UINT,
+  eR32G32B32A32Sint = VK_FORMAT_R32G32B32A32_SINT,
+  eR32G32B32A32Sfloat = VK_FORMAT_R32G32B32A32_SFLOAT,
+  eR64Uint = VK_FORMAT_R64_UINT,
+  eR64Sint = VK_FORMAT_R64_SINT,
+  eR64Sfloat = VK_FORMAT_R64_SFLOAT,
+  eR64G64Uint = VK_FORMAT_R64G64_UINT,
+  eR64G64Sint = VK_FORMAT_R64G64_SINT,
+  eR64G64Sfloat = VK_FORMAT_R64G64_SFLOAT,
+  eR64G64B64Uint = VK_FORMAT_R64G64B64_UINT,
+  eR64G64B64Sint = VK_FORMAT_R64G64B64_SINT,
+  eR64G64B64Sfloat = VK_FORMAT_R64G64B64_SFLOAT,
+  eR64G64B64A64Uint = VK_FORMAT_R64G64B64A64_UINT,
+  eR64G64B64A64Sint = VK_FORMAT_R64G64B64A64_SINT,
+  eR64G64B64A64Sfloat = VK_FORMAT_R64G64B64A64_SFLOAT,
+  eB10G11R11UfloatPack32 = VK_FORMAT_B10G11R11_UFLOAT_PACK32,
+  eE5B9G9R9UfloatPack32 = VK_FORMAT_E5B9G9R9_UFLOAT_PACK32,
+  eD16Unorm = VK_FORMAT_D16_UNORM,
+  eX8D24UnormPack32 = VK_FORMAT_X8_D24_UNORM_PACK32,
+  eD32Sfloat = VK_FORMAT_D32_SFLOAT,
+  eS8Uint = VK_FORMAT_S8_UINT,
+  eD16UnormS8Uint = VK_FORMAT_D16_UNORM_S8_UINT,
+  eD24UnormS8Uint = VK_FORMAT_D24_UNORM_S8_UINT,
+  eD32SfloatS8Uint = VK_FORMAT_D32_SFLOAT_S8_UINT,
+  eBc1RgbUnormBlock = VK_FORMAT_BC1_RGB_UNORM_BLOCK,
+  eBc1RgbSrgbBlock = VK_FORMAT_BC1_RGB_SRGB_BLOCK,
+  eBc1RgbaUnormBlock = VK_FORMAT_BC1_RGBA_UNORM_BLOCK,
+  eBc1RgbaSrgbBlock = VK_FORMAT_BC1_RGBA_SRGB_BLOCK,
+  eBc2UnormBlock = VK_FORMAT_BC2_UNORM_BLOCK,
+  eBc2SrgbBlock = VK_FORMAT_BC2_SRGB_BLOCK,
+  eBc3UnormBlock = VK_FORMAT_BC3_UNORM_BLOCK,
+  eBc3SrgbBlock = VK_FORMAT_BC3_SRGB_BLOCK,
+  eBc4UnormBlock = VK_FORMAT_BC4_UNORM_BLOCK,
+  eBc4SnormBlock = VK_FORMAT_BC4_SNORM_BLOCK,
+  eBc5UnormBlock = VK_FORMAT_BC5_UNORM_BLOCK,
+  eBc5SnormBlock = VK_FORMAT_BC5_SNORM_BLOCK,
+  eBc6HUfloatBlock = VK_FORMAT_BC6H_UFLOAT_BLOCK,
+  eBc6HSfloatBlock = VK_FORMAT_BC6H_SFLOAT_BLOCK,
+  eBc7UnormBlock = VK_FORMAT_BC7_UNORM_BLOCK,
+  eBc7SrgbBlock = VK_FORMAT_BC7_SRGB_BLOCK,
+  eEtc2R8G8B8UnormBlock = VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK,
+  eEtc2R8G8B8SrgbBlock = VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK,
+  eEtc2R8G8B8A1UnormBlock = VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK,
+  eEtc2R8G8B8A1SrgbBlock = VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK,
+  eEtc2R8G8B8A8UnormBlock = VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK,
+  eEtc2R8G8B8A8SrgbBlock = VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK,
+  eEacR11UnormBlock = VK_FORMAT_EAC_R11_UNORM_BLOCK,
+  eEacR11SnormBlock = VK_FORMAT_EAC_R11_SNORM_BLOCK,
+  eEacR11G11UnormBlock = VK_FORMAT_EAC_R11G11_UNORM_BLOCK,
+  eEacR11G11SnormBlock = VK_FORMAT_EAC_R11G11_SNORM_BLOCK,
+  eAstc4x4UnormBlock = VK_FORMAT_ASTC_4x4_UNORM_BLOCK,
+  eAstc4x4SrgbBlock = VK_FORMAT_ASTC_4x4_SRGB_BLOCK,
+  eAstc5x4UnormBlock = VK_FORMAT_ASTC_5x4_UNORM_BLOCK,
+  eAstc5x4SrgbBlock = VK_FORMAT_ASTC_5x4_SRGB_BLOCK,
+  eAstc5x5UnormBlock = VK_FORMAT_ASTC_5x5_UNORM_BLOCK,
+  eAstc5x5SrgbBlock = VK_FORMAT_ASTC_5x5_SRGB_BLOCK,
+  eAstc6x5UnormBlock = VK_FORMAT_ASTC_6x5_UNORM_BLOCK,
+  eAstc6x5SrgbBlock = VK_FORMAT_ASTC_6x5_SRGB_BLOCK,
+  eAstc6x6UnormBlock = VK_FORMAT_ASTC_6x6_UNORM_BLOCK,
+  eAstc6x6SrgbBlock = VK_FORMAT_ASTC_6x6_SRGB_BLOCK,
+  eAstc8x5UnormBlock = VK_FORMAT_ASTC_8x5_UNORM_BLOCK,
+  eAstc8x5SrgbBlock = VK_FORMAT_ASTC_8x5_SRGB_BLOCK,
+  eAstc8x6UnormBlock = VK_FORMAT_ASTC_8x6_UNORM_BLOCK,
+  eAstc8x6SrgbBlock = VK_FORMAT_ASTC_8x6_SRGB_BLOCK,
+  eAstc8x8UnormBlock = VK_FORMAT_ASTC_8x8_UNORM_BLOCK,
+  eAstc8x8SrgbBlock = VK_FORMAT_ASTC_8x8_SRGB_BLOCK,
+  eAstc10x5UnormBlock = VK_FORMAT_ASTC_10x5_UNORM_BLOCK,
+  eAstc10x5SrgbBlock = VK_FORMAT_ASTC_10x5_SRGB_BLOCK,
+  eAstc10x6UnormBlock = VK_FORMAT_ASTC_10x6_UNORM_BLOCK,
+  eAstc10x6SrgbBlock = VK_FORMAT_ASTC_10x6_SRGB_BLOCK,
+  eAstc10x8UnormBlock = VK_FORMAT_ASTC_10x8_UNORM_BLOCK,
+  eAstc10x8SrgbBlock = VK_FORMAT_ASTC_10x8_SRGB_BLOCK,
+  eAstc10x10UnormBlock = VK_FORMAT_ASTC_10x10_UNORM_BLOCK,
+  eAstc10x10SrgbBlock = VK_FORMAT_ASTC_10x10_SRGB_BLOCK,
+  eAstc12x10UnormBlock = VK_FORMAT_ASTC_12x10_UNORM_BLOCK,
+  eAstc12x10SrgbBlock = VK_FORMAT_ASTC_12x10_SRGB_BLOCK,
+  eAstc12x12UnormBlock = VK_FORMAT_ASTC_12x12_UNORM_BLOCK,
+  eAstc12x12SrgbBlock = VK_FORMAT_ASTC_12x12_SRGB_BLOCK,
+  eG8B8G8R8422Unorm = VK_FORMAT_G8B8G8R8_422_UNORM,
+  eB8G8R8G8422Unorm = VK_FORMAT_B8G8R8G8_422_UNORM,
+  eG8B8R83Plane420Unorm = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM,
+  eG8B8R82Plane420Unorm = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM,
+  eG8B8R83Plane422Unorm = VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM,
+  eG8B8R82Plane422Unorm = VK_FORMAT_G8_B8R8_2PLANE_422_UNORM,
+  eG8B8R83Plane444Unorm = VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM,
+  eR10X6UnormPack16 = VK_FORMAT_R10X6_UNORM_PACK16,
+  eR10X6G10X6Unorm2Pack16 = VK_FORMAT_R10X6G10X6_UNORM_2PACK16,
+  eR10X6G10X6B10X6A10X6Unorm4Pack16 =
+      VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16,
+  eG10X6B10X6G10X6R10X6422Unorm4Pack16 =
+      VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16,
+  eB10X6G10X6R10X6G10X6422Unorm4Pack16 =
+      VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16,
+  eG10X6B10X6R10X63Plane420Unorm3Pack16 =
+      VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16,
+  eG10X6B10X6R10X62Plane420Unorm3Pack16 =
+      VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16,
+  eG10X6B10X6R10X63Plane422Unorm3Pack16 =
+      VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16,
+  eG10X6B10X6R10X62Plane422Unorm3Pack16 =
+      VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16,
+  eG10X6B10X6R10X63Plane444Unorm3Pack16 =
+      VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16,
+  eR12X4UnormPack16 = VK_FORMAT_R12X4_UNORM_PACK16,
+  eR12X4G12X4Unorm2Pack16 = VK_FORMAT_R12X4G12X4_UNORM_2PACK16,
+  eR12X4G12X4B12X4A12X4Unorm4Pack16 =
+      VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16,
+  eG12X4B12X4G12X4R12X4422Unorm4Pack16 =
+      VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16,
+  eB12X4G12X4R12X4G12X4422Unorm4Pack16 =
+      VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16,
+  eG12X4B12X4R12X43Plane420Unorm3Pack16 =
+      VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16,
+  eG12X4B12X4R12X42Plane420Unorm3Pack16 =
+      VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16,
+  eG12X4B12X4R12X43Plane422Unorm3Pack16 =
+      VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16,
+  eG12X4B12X4R12X42Plane422Unorm3Pack16 =
+      VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16,
+  eG12X4B12X4R12X43Plane444Unorm3Pack16 =
+      VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16,
+  eG16B16G16R16422Unorm = VK_FORMAT_G16B16G16R16_422_UNORM,
+  eB16G16R16G16422Unorm = VK_FORMAT_B16G16R16G16_422_UNORM,
+  eG16B16R163Plane420Unorm = VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM,
+  eG16B16R162Plane420Unorm = VK_FORMAT_G16_B16R16_2PLANE_420_UNORM,
+  eG16B16R163Plane422Unorm = VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM,
+  eG16B16R162Plane422Unorm = VK_FORMAT_G16_B16R16_2PLANE_422_UNORM,
+  eG16B16R163Plane444Unorm = VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM,
+  ePvrtc12BppUnormBlockIMG = VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG,
+  ePvrtc14BppUnormBlockIMG = VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG,
+  ePvrtc22BppUnormBlockIMG = VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG,
+  ePvrtc24BppUnormBlockIMG = VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG,
+  ePvrtc12BppSrgbBlockIMG = VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG,
+  ePvrtc14BppSrgbBlockIMG = VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG,
+  ePvrtc22BppSrgbBlockIMG = VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG,
+  ePvrtc24BppSrgbBlockIMG = VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG,
+  eAstc4x4SfloatBlockEXT = VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT,
+  eAstc5x4SfloatBlockEXT = VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT,
+  eAstc5x5SfloatBlockEXT = VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT,
+  eAstc6x5SfloatBlockEXT = VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT,
+  eAstc6x6SfloatBlockEXT = VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT,
+  eAstc8x5SfloatBlockEXT = VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT,
+  eAstc8x6SfloatBlockEXT = VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT,
+  eAstc8x8SfloatBlockEXT = VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT,
+  eAstc10x5SfloatBlockEXT = VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT,
+  eAstc10x6SfloatBlockEXT = VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT,
+  eAstc10x8SfloatBlockEXT = VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT,
+  eAstc10x10SfloatBlockEXT = VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT,
+  eAstc12x10SfloatBlockEXT = VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT,
+  eAstc12x12SfloatBlockEXT = VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT,
+  eA4R4G4B4UnormPack16EXT = VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT,
+  eA4B4G4R4UnormPack16EXT = VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT,
+  eB10X6G10X6R10X6G10X6422Unorm4Pack16KHR =
+      VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR,
+  eB12X4G12X4R12X4G12X4422Unorm4Pack16KHR =
+      VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR,
+  eB16G16R16G16422UnormKHR = VK_FORMAT_B16G16R16G16_422_UNORM_KHR,
+  eB8G8R8G8422UnormKHR = VK_FORMAT_B8G8R8G8_422_UNORM_KHR,
+  eG10X6B10X6G10X6R10X6422Unorm4Pack16KHR =
+      VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR,
+  eG10X6B10X6R10X62Plane420Unorm3Pack16KHR =
+      VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR,
+  eG10X6B10X6R10X62Plane422Unorm3Pack16KHR =
+      VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR,
+  eG10X6B10X6R10X63Plane420Unorm3Pack16KHR =
+      VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR,
+  eG10X6B10X6R10X63Plane422Unorm3Pack16KHR =
+      VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR,
+  eG10X6B10X6R10X63Plane444Unorm3Pack16KHR =
+      VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR,
+  eG12X4B12X4G12X4R12X4422Unorm4Pack16KHR =
+      VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR,
+  eG12X4B12X4R12X42Plane420Unorm3Pack16KHR =
+      VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR,
+  eG12X4B12X4R12X42Plane422Unorm3Pack16KHR =
+      VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR,
+  eG12X4B12X4R12X43Plane420Unorm3Pack16KHR =
+      VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR,
+  eG12X4B12X4R12X43Plane422Unorm3Pack16KHR =
+      VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR,
+  eG12X4B12X4R12X43Plane444Unorm3Pack16KHR =
+      VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR,
+  eG16B16G16R16422UnormKHR = VK_FORMAT_G16B16G16R16_422_UNORM_KHR,
+  eG16B16R162Plane420UnormKHR = VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR,
+  eG16B16R162Plane422UnormKHR = VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR,
+  eG16B16R163Plane420UnormKHR = VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR,
+  eG16B16R163Plane422UnormKHR = VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR,
+  eG16B16R163Plane444UnormKHR = VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR,
+  eG8B8G8R8422UnormKHR = VK_FORMAT_G8B8G8R8_422_UNORM_KHR,
+  eG8B8R82Plane420UnormKHR = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR,
+  eG8B8R82Plane422UnormKHR = VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR,
+  eG8B8R83Plane420UnormKHR = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR,
+  eG8B8R83Plane422UnormKHR = VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR,
+  eG8B8R83Plane444UnormKHR = VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR,
+  eR10X6G10X6B10X6A10X6Unorm4Pack16KHR =
+      VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR,
+  eR10X6G10X6Unorm2Pack16KHR = VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR,
+  eR10X6UnormPack16KHR = VK_FORMAT_R10X6_UNORM_PACK16_KHR,
+  eR12X4G12X4B12X4A12X4Unorm4Pack16KHR =
+      VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR,
+  eR12X4G12X4Unorm2Pack16KHR = VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR,
+  eR12X4UnormPack16KHR = VK_FORMAT_R12X4_UNORM_PACK16_KHR
+};
+
+VULKAN_HPP_INLINE std::string to_string(Format value) {
+  switch (value) {
+  case Format::eUndefined:
+    return "Undefined";
+  case Format::eR4G4UnormPack8:
+    return "R4G4UnormPack8";
+  case Format::eR4G4B4A4UnormPack16:
+    return "R4G4B4A4UnormPack16";
+  case Format::eB4G4R4A4UnormPack16:
+    return "B4G4R4A4UnormPack16";
+  case Format::eR5G6B5UnormPack16:
+    return "R5G6B5UnormPack16";
+  case Format::eB5G6R5UnormPack16:
+    return "B5G6R5UnormPack16";
+  case Format::eR5G5B5A1UnormPack16:
+    return "R5G5B5A1UnormPack16";
+  case Format::eB5G5R5A1UnormPack16:
+    return "B5G5R5A1UnormPack16";
+  case Format::eA1R5G5B5UnormPack16:
+    return "A1R5G5B5UnormPack16";
+  case Format::eR8Unorm:
+    return "R8Unorm";
+  case Format::eR8Snorm:
+    return "R8Snorm";
+  case Format::eR8Uscaled:
+    return "R8Uscaled";
+  case Format::eR8Sscaled:
+    return "R8Sscaled";
+  case Format::eR8Uint:
+    return "R8Uint";
+  case Format::eR8Sint:
+    return "R8Sint";
+  case Format::eR8Srgb:
+    return "R8Srgb";
+  case Format::eR8G8Unorm:
+    return "R8G8Unorm";
+  case Format::eR8G8Snorm:
+    return "R8G8Snorm";
+  case Format::eR8G8Uscaled:
+    return "R8G8Uscaled";
+  case Format::eR8G8Sscaled:
+    return "R8G8Sscaled";
+  case Format::eR8G8Uint:
+    return "R8G8Uint";
+  case Format::eR8G8Sint:
+    return "R8G8Sint";
+  case Format::eR8G8Srgb:
+    return "R8G8Srgb";
+  case Format::eR8G8B8Unorm:
+    return "R8G8B8Unorm";
+  case Format::eR8G8B8Snorm:
+    return "R8G8B8Snorm";
+  case Format::eR8G8B8Uscaled:
+    return "R8G8B8Uscaled";
+  case Format::eR8G8B8Sscaled:
+    return "R8G8B8Sscaled";
+  case Format::eR8G8B8Uint:
+    return "R8G8B8Uint";
+  case Format::eR8G8B8Sint:
+    return "R8G8B8Sint";
+  case Format::eR8G8B8Srgb:
+    return "R8G8B8Srgb";
+  case Format::eB8G8R8Unorm:
+    return "B8G8R8Unorm";
+  case Format::eB8G8R8Snorm:
+    return "B8G8R8Snorm";
+  case Format::eB8G8R8Uscaled:
+    return "B8G8R8Uscaled";
+  case Format::eB8G8R8Sscaled:
+    return "B8G8R8Sscaled";
+  case Format::eB8G8R8Uint:
+    return "B8G8R8Uint";
+  case Format::eB8G8R8Sint:
+    return "B8G8R8Sint";
+  case Format::eB8G8R8Srgb:
+    return "B8G8R8Srgb";
+  case Format::eR8G8B8A8Unorm:
+    return "R8G8B8A8Unorm";
+  case Format::eR8G8B8A8Snorm:
+    return "R8G8B8A8Snorm";
+  case Format::eR8G8B8A8Uscaled:
+    return "R8G8B8A8Uscaled";
+  case Format::eR8G8B8A8Sscaled:
+    return "R8G8B8A8Sscaled";
+  case Format::eR8G8B8A8Uint:
+    return "R8G8B8A8Uint";
+  case Format::eR8G8B8A8Sint:
+    return "R8G8B8A8Sint";
+  case Format::eR8G8B8A8Srgb:
+    return "R8G8B8A8Srgb";
+  case Format::eB8G8R8A8Unorm:
+    return "B8G8R8A8Unorm";
+  case Format::eB8G8R8A8Snorm:
+    return "B8G8R8A8Snorm";
+  case Format::eB8G8R8A8Uscaled:
+    return "B8G8R8A8Uscaled";
+  case Format::eB8G8R8A8Sscaled:
+    return "B8G8R8A8Sscaled";
+  case Format::eB8G8R8A8Uint:
+    return "B8G8R8A8Uint";
+  case Format::eB8G8R8A8Sint:
+    return "B8G8R8A8Sint";
+  case Format::eB8G8R8A8Srgb:
+    return "B8G8R8A8Srgb";
+  case Format::eA8B8G8R8UnormPack32:
+    return "A8B8G8R8UnormPack32";
+  case Format::eA8B8G8R8SnormPack32:
+    return "A8B8G8R8SnormPack32";
+  case Format::eA8B8G8R8UscaledPack32:
+    return "A8B8G8R8UscaledPack32";
+  case Format::eA8B8G8R8SscaledPack32:
+    return "A8B8G8R8SscaledPack32";
+  case Format::eA8B8G8R8UintPack32:
+    return "A8B8G8R8UintPack32";
+  case Format::eA8B8G8R8SintPack32:
+    return "A8B8G8R8SintPack32";
+  case Format::eA8B8G8R8SrgbPack32:
+    return "A8B8G8R8SrgbPack32";
+  case Format::eA2R10G10B10UnormPack32:
+    return "A2R10G10B10UnormPack32";
+  case Format::eA2R10G10B10SnormPack32:
+    return "A2R10G10B10SnormPack32";
+  case Format::eA2R10G10B10UscaledPack32:
+    return "A2R10G10B10UscaledPack32";
+  case Format::eA2R10G10B10SscaledPack32:
+    return "A2R10G10B10SscaledPack32";
+  case Format::eA2R10G10B10UintPack32:
+    return "A2R10G10B10UintPack32";
+  case Format::eA2R10G10B10SintPack32:
+    return "A2R10G10B10SintPack32";
+  case Format::eA2B10G10R10UnormPack32:
+    return "A2B10G10R10UnormPack32";
+  case Format::eA2B10G10R10SnormPack32:
+    return "A2B10G10R10SnormPack32";
+  case Format::eA2B10G10R10UscaledPack32:
+    return "A2B10G10R10UscaledPack32";
+  case Format::eA2B10G10R10SscaledPack32:
+    return "A2B10G10R10SscaledPack32";
+  case Format::eA2B10G10R10UintPack32:
+    return "A2B10G10R10UintPack32";
+  case Format::eA2B10G10R10SintPack32:
+    return "A2B10G10R10SintPack32";
+  case Format::eR16Unorm:
+    return "R16Unorm";
+  case Format::eR16Snorm:
+    return "R16Snorm";
+  case Format::eR16Uscaled:
+    return "R16Uscaled";
+  case Format::eR16Sscaled:
+    return "R16Sscaled";
+  case Format::eR16Uint:
+    return "R16Uint";
+  case Format::eR16Sint:
+    return "R16Sint";
+  case Format::eR16Sfloat:
+    return "R16Sfloat";
+  case Format::eR16G16Unorm:
+    return "R16G16Unorm";
+  case Format::eR16G16Snorm:
+    return "R16G16Snorm";
+  case Format::eR16G16Uscaled:
+    return "R16G16Uscaled";
+  case Format::eR16G16Sscaled:
+    return "R16G16Sscaled";
+  case Format::eR16G16Uint:
+    return "R16G16Uint";
+  case Format::eR16G16Sint:
+    return "R16G16Sint";
+  case Format::eR16G16Sfloat:
+    return "R16G16Sfloat";
+  case Format::eR16G16B16Unorm:
+    return "R16G16B16Unorm";
+  case Format::eR16G16B16Snorm:
+    return "R16G16B16Snorm";
+  case Format::eR16G16B16Uscaled:
+    return "R16G16B16Uscaled";
+  case Format::eR16G16B16Sscaled:
+    return "R16G16B16Sscaled";
+  case Format::eR16G16B16Uint:
+    return "R16G16B16Uint";
+  case Format::eR16G16B16Sint:
+    return "R16G16B16Sint";
+  case Format::eR16G16B16Sfloat:
+    return "R16G16B16Sfloat";
+  case Format::eR16G16B16A16Unorm:
+    return "R16G16B16A16Unorm";
+  case Format::eR16G16B16A16Snorm:
+    return "R16G16B16A16Snorm";
+  case Format::eR16G16B16A16Uscaled:
+    return "R16G16B16A16Uscaled";
+  case Format::eR16G16B16A16Sscaled:
+    return "R16G16B16A16Sscaled";
+  case Format::eR16G16B16A16Uint:
+    return "R16G16B16A16Uint";
+  case Format::eR16G16B16A16Sint:
+    return "R16G16B16A16Sint";
+  case Format::eR16G16B16A16Sfloat:
+    return "R16G16B16A16Sfloat";
+  case Format::eR32Uint:
+    return "R32Uint";
+  case Format::eR32Sint:
+    return "R32Sint";
+  case Format::eR32Sfloat:
+    return "R32Sfloat";
+  case Format::eR32G32Uint:
+    return "R32G32Uint";
+  case Format::eR32G32Sint:
+    return "R32G32Sint";
+  case Format::eR32G32Sfloat:
+    return "R32G32Sfloat";
+  case Format::eR32G32B32Uint:
+    return "R32G32B32Uint";
+  case Format::eR32G32B32Sint:
+    return "R32G32B32Sint";
+  case Format::eR32G32B32Sfloat:
+    return "R32G32B32Sfloat";
+  case Format::eR32G32B32A32Uint:
+    return "R32G32B32A32Uint";
+  case Format::eR32G32B32A32Sint:
+    return "R32G32B32A32Sint";
+  case Format::eR32G32B32A32Sfloat:
+    return "R32G32B32A32Sfloat";
+  case Format::eR64Uint:
+    return "R64Uint";
+  case Format::eR64Sint:
+    return "R64Sint";
+  case Format::eR64Sfloat:
+    return "R64Sfloat";
+  case Format::eR64G64Uint:
+    return "R64G64Uint";
+  case Format::eR64G64Sint:
+    return "R64G64Sint";
+  case Format::eR64G64Sfloat:
+    return "R64G64Sfloat";
+  case Format::eR64G64B64Uint:
+    return "R64G64B64Uint";
+  case Format::eR64G64B64Sint:
+    return "R64G64B64Sint";
+  case Format::eR64G64B64Sfloat:
+    return "R64G64B64Sfloat";
+  case Format::eR64G64B64A64Uint:
+    return "R64G64B64A64Uint";
+  case Format::eR64G64B64A64Sint:
+    return "R64G64B64A64Sint";
+  case Format::eR64G64B64A64Sfloat:
+    return "R64G64B64A64Sfloat";
+  case Format::eB10G11R11UfloatPack32:
+    return "B10G11R11UfloatPack32";
+  case Format::eE5B9G9R9UfloatPack32:
+    return "E5B9G9R9UfloatPack32";
+  case Format::eD16Unorm:
+    return "D16Unorm";
+  case Format::eX8D24UnormPack32:
+    return "X8D24UnormPack32";
+  case Format::eD32Sfloat:
+    return "D32Sfloat";
+  case Format::eS8Uint:
+    return "S8Uint";
+  case Format::eD16UnormS8Uint:
+    return "D16UnormS8Uint";
+  case Format::eD24UnormS8Uint:
+    return "D24UnormS8Uint";
+  case Format::eD32SfloatS8Uint:
+    return "D32SfloatS8Uint";
+  case Format::eBc1RgbUnormBlock:
+    return "Bc1RgbUnormBlock";
+  case Format::eBc1RgbSrgbBlock:
+    return "Bc1RgbSrgbBlock";
+  case Format::eBc1RgbaUnormBlock:
+    return "Bc1RgbaUnormBlock";
+  case Format::eBc1RgbaSrgbBlock:
+    return "Bc1RgbaSrgbBlock";
+  case Format::eBc2UnormBlock:
+    return "Bc2UnormBlock";
+  case Format::eBc2SrgbBlock:
+    return "Bc2SrgbBlock";
+  case Format::eBc3UnormBlock:
+    return "Bc3UnormBlock";
+  case Format::eBc3SrgbBlock:
+    return "Bc3SrgbBlock";
+  case Format::eBc4UnormBlock:
+    return "Bc4UnormBlock";
+  case Format::eBc4SnormBlock:
+    return "Bc4SnormBlock";
+  case Format::eBc5UnormBlock:
+    return "Bc5UnormBlock";
+  case Format::eBc5SnormBlock:
+    return "Bc5SnormBlock";
+  case Format::eBc6HUfloatBlock:
+    return "Bc6HUfloatBlock";
+  case Format::eBc6HSfloatBlock:
+    return "Bc6HSfloatBlock";
+  case Format::eBc7UnormBlock:
+    return "Bc7UnormBlock";
+  case Format::eBc7SrgbBlock:
+    return "Bc7SrgbBlock";
+  case Format::eEtc2R8G8B8UnormBlock:
+    return "Etc2R8G8B8UnormBlock";
+  case Format::eEtc2R8G8B8SrgbBlock:
+    return "Etc2R8G8B8SrgbBlock";
+  case Format::eEtc2R8G8B8A1UnormBlock:
+    return "Etc2R8G8B8A1UnormBlock";
+  case Format::eEtc2R8G8B8A1SrgbBlock:
+    return "Etc2R8G8B8A1SrgbBlock";
+  case Format::eEtc2R8G8B8A8UnormBlock:
+    return "Etc2R8G8B8A8UnormBlock";
+  case Format::eEtc2R8G8B8A8SrgbBlock:
+    return "Etc2R8G8B8A8SrgbBlock";
+  case Format::eEacR11UnormBlock:
+    return "EacR11UnormBlock";
+  case Format::eEacR11SnormBlock:
+    return "EacR11SnormBlock";
+  case Format::eEacR11G11UnormBlock:
+    return "EacR11G11UnormBlock";
+  case Format::eEacR11G11SnormBlock:
+    return "EacR11G11SnormBlock";
+  case Format::eAstc4x4UnormBlock:
+    return "Astc4x4UnormBlock";
+  case Format::eAstc4x4SrgbBlock:
+    return "Astc4x4SrgbBlock";
+  case Format::eAstc5x4UnormBlock:
+    return "Astc5x4UnormBlock";
+  case Format::eAstc5x4SrgbBlock:
+    return "Astc5x4SrgbBlock";
+  case Format::eAstc5x5UnormBlock:
+    return "Astc5x5UnormBlock";
+  case Format::eAstc5x5SrgbBlock:
+    return "Astc5x5SrgbBlock";
+  case Format::eAstc6x5UnormBlock:
+    return "Astc6x5UnormBlock";
+  case Format::eAstc6x5SrgbBlock:
+    return "Astc6x5SrgbBlock";
+  case Format::eAstc6x6UnormBlock:
+    return "Astc6x6UnormBlock";
+  case Format::eAstc6x6SrgbBlock:
+    return "Astc6x6SrgbBlock";
+  case Format::eAstc8x5UnormBlock:
+    return "Astc8x5UnormBlock";
+  case Format::eAstc8x5SrgbBlock:
+    return "Astc8x5SrgbBlock";
+  case Format::eAstc8x6UnormBlock:
+    return "Astc8x6UnormBlock";
+  case Format::eAstc8x6SrgbBlock:
+    return "Astc8x6SrgbBlock";
+  case Format::eAstc8x8UnormBlock:
+    return "Astc8x8UnormBlock";
+  case Format::eAstc8x8SrgbBlock:
+    return "Astc8x8SrgbBlock";
+  case Format::eAstc10x5UnormBlock:
+    return "Astc10x5UnormBlock";
+  case Format::eAstc10x5SrgbBlock:
+    return "Astc10x5SrgbBlock";
+  case Format::eAstc10x6UnormBlock:
+    return "Astc10x6UnormBlock";
+  case Format::eAstc10x6SrgbBlock:
+    return "Astc10x6SrgbBlock";
+  case Format::eAstc10x8UnormBlock:
+    return "Astc10x8UnormBlock";
+  case Format::eAstc10x8SrgbBlock:
+    return "Astc10x8SrgbBlock";
+  case Format::eAstc10x10UnormBlock:
+    return "Astc10x10UnormBlock";
+  case Format::eAstc10x10SrgbBlock:
+    return "Astc10x10SrgbBlock";
+  case Format::eAstc12x10UnormBlock:
+    return "Astc12x10UnormBlock";
+  case Format::eAstc12x10SrgbBlock:
+    return "Astc12x10SrgbBlock";
+  case Format::eAstc12x12UnormBlock:
+    return "Astc12x12UnormBlock";
+  case Format::eAstc12x12SrgbBlock:
+    return "Astc12x12SrgbBlock";
+  case Format::eG8B8G8R8422Unorm:
+    return "G8B8G8R8422Unorm";
+  case Format::eB8G8R8G8422Unorm:
+    return "B8G8R8G8422Unorm";
+  case Format::eG8B8R83Plane420Unorm:
+    return "G8B8R83Plane420Unorm";
+  case Format::eG8B8R82Plane420Unorm:
+    return "G8B8R82Plane420Unorm";
+  case Format::eG8B8R83Plane422Unorm:
+    return "G8B8R83Plane422Unorm";
+  case Format::eG8B8R82Plane422Unorm:
+    return "G8B8R82Plane422Unorm";
+  case Format::eG8B8R83Plane444Unorm:
+    return "G8B8R83Plane444Unorm";
+  case Format::eR10X6UnormPack16:
+    return "R10X6UnormPack16";
+  case Format::eR10X6G10X6Unorm2Pack16:
+    return "R10X6G10X6Unorm2Pack16";
+  case Format::eR10X6G10X6B10X6A10X6Unorm4Pack16:
+    return "R10X6G10X6B10X6A10X6Unorm4Pack16";
+  case Format::eG10X6B10X6G10X6R10X6422Unorm4Pack16:
+    return "G10X6B10X6G10X6R10X6422Unorm4Pack16";
+  case Format::eB10X6G10X6R10X6G10X6422Unorm4Pack16:
+    return "B10X6G10X6R10X6G10X6422Unorm4Pack16";
+  case Format::eG10X6B10X6R10X63Plane420Unorm3Pack16:
+    return "G10X6B10X6R10X63Plane420Unorm3Pack16";
+  case Format::eG10X6B10X6R10X62Plane420Unorm3Pack16:
+    return "G10X6B10X6R10X62Plane420Unorm3Pack16";
+  case Format::eG10X6B10X6R10X63Plane422Unorm3Pack16:
+    return "G10X6B10X6R10X63Plane422Unorm3Pack16";
+  case Format::eG10X6B10X6R10X62Plane422Unorm3Pack16:
+    return "G10X6B10X6R10X62Plane422Unorm3Pack16";
+  case Format::eG10X6B10X6R10X63Plane444Unorm3Pack16:
+    return "G10X6B10X6R10X63Plane444Unorm3Pack16";
+  case Format::eR12X4UnormPack16:
+    return "R12X4UnormPack16";
+  case Format::eR12X4G12X4Unorm2Pack16:
+    return "R12X4G12X4Unorm2Pack16";
+  case Format::eR12X4G12X4B12X4A12X4Unorm4Pack16:
+    return "R12X4G12X4B12X4A12X4Unorm4Pack16";
+  case Format::eG12X4B12X4G12X4R12X4422Unorm4Pack16:
+    return "G12X4B12X4G12X4R12X4422Unorm4Pack16";
+  case Format::eB12X4G12X4R12X4G12X4422Unorm4Pack16:
+    return "B12X4G12X4R12X4G12X4422Unorm4Pack16";
+  case Format::eG12X4B12X4R12X43Plane420Unorm3Pack16:
+    return "G12X4B12X4R12X43Plane420Unorm3Pack16";
+  case Format::eG12X4B12X4R12X42Plane420Unorm3Pack16:
+    return "G12X4B12X4R12X42Plane420Unorm3Pack16";
+  case Format::eG12X4B12X4R12X43Plane422Unorm3Pack16:
+    return "G12X4B12X4R12X43Plane422Unorm3Pack16";
+  case Format::eG12X4B12X4R12X42Plane422Unorm3Pack16:
+    return "G12X4B12X4R12X42Plane422Unorm3Pack16";
+  case Format::eG12X4B12X4R12X43Plane444Unorm3Pack16:
+    return "G12X4B12X4R12X43Plane444Unorm3Pack16";
+  case Format::eG16B16G16R16422Unorm:
+    return "G16B16G16R16422Unorm";
+  case Format::eB16G16R16G16422Unorm:
+    return "B16G16R16G16422Unorm";
+  case Format::eG16B16R163Plane420Unorm:
+    return "G16B16R163Plane420Unorm";
+  case Format::eG16B16R162Plane420Unorm:
+    return "G16B16R162Plane420Unorm";
+  case Format::eG16B16R163Plane422Unorm:
+    return "G16B16R163Plane422Unorm";
+  case Format::eG16B16R162Plane422Unorm:
+    return "G16B16R162Plane422Unorm";
+  case Format::eG16B16R163Plane444Unorm:
+    return "G16B16R163Plane444Unorm";
+  case Format::ePvrtc12BppUnormBlockIMG:
+    return "Pvrtc12BppUnormBlockIMG";
+  case Format::ePvrtc14BppUnormBlockIMG:
+    return "Pvrtc14BppUnormBlockIMG";
+  case Format::ePvrtc22BppUnormBlockIMG:
+    return "Pvrtc22BppUnormBlockIMG";
+  case Format::ePvrtc24BppUnormBlockIMG:
+    return "Pvrtc24BppUnormBlockIMG";
+  case Format::ePvrtc12BppSrgbBlockIMG:
+    return "Pvrtc12BppSrgbBlockIMG";
+  case Format::ePvrtc14BppSrgbBlockIMG:
+    return "Pvrtc14BppSrgbBlockIMG";
+  case Format::ePvrtc22BppSrgbBlockIMG:
+    return "Pvrtc22BppSrgbBlockIMG";
+  case Format::ePvrtc24BppSrgbBlockIMG:
+    return "Pvrtc24BppSrgbBlockIMG";
+  case Format::eAstc4x4SfloatBlockEXT:
+    return "Astc4x4SfloatBlockEXT";
+  case Format::eAstc5x4SfloatBlockEXT:
+    return "Astc5x4SfloatBlockEXT";
+  case Format::eAstc5x5SfloatBlockEXT:
+    return "Astc5x5SfloatBlockEXT";
+  case Format::eAstc6x5SfloatBlockEXT:
+    return "Astc6x5SfloatBlockEXT";
+  case Format::eAstc6x6SfloatBlockEXT:
+    return "Astc6x6SfloatBlockEXT";
+  case Format::eAstc8x5SfloatBlockEXT:
+    return "Astc8x5SfloatBlockEXT";
+  case Format::eAstc8x6SfloatBlockEXT:
+    return "Astc8x6SfloatBlockEXT";
+  case Format::eAstc8x8SfloatBlockEXT:
+    return "Astc8x8SfloatBlockEXT";
+  case Format::eAstc10x5SfloatBlockEXT:
+    return "Astc10x5SfloatBlockEXT";
+  case Format::eAstc10x6SfloatBlockEXT:
+    return "Astc10x6SfloatBlockEXT";
+  case Format::eAstc10x8SfloatBlockEXT:
+    return "Astc10x8SfloatBlockEXT";
+  case Format::eAstc10x10SfloatBlockEXT:
+    return "Astc10x10SfloatBlockEXT";
+  case Format::eAstc12x10SfloatBlockEXT:
+    return "Astc12x10SfloatBlockEXT";
+  case Format::eAstc12x12SfloatBlockEXT:
+    return "Astc12x12SfloatBlockEXT";
+  case Format::eA4R4G4B4UnormPack16EXT:
+    return "A4R4G4B4UnormPack16EXT";
+  case Format::eA4B4G4R4UnormPack16EXT:
+    return "A4B4G4R4UnormPack16EXT";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class FormatFeatureFlagBits : VkFormatFeatureFlags {
+  eSampledImage = VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT,
+  eStorageImage = VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT,
+  eStorageImageAtomic = VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT,
+  eUniformTexelBuffer = VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT,
+  eStorageTexelBuffer = VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT,
+  eStorageTexelBufferAtomic = VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT,
+  eVertexBuffer = VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT,
+  eColorAttachment = VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT,
+  eColorAttachmentBlend = VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT,
+  eDepthStencilAttachment = VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT,
+  eBlitSrc = VK_FORMAT_FEATURE_BLIT_SRC_BIT,
+  eBlitDst = VK_FORMAT_FEATURE_BLIT_DST_BIT,
+  eSampledImageFilterLinear = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT,
+  eTransferSrc = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT,
+  eTransferDst = VK_FORMAT_FEATURE_TRANSFER_DST_BIT,
+  eMidpointChromaSamples = VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT,
+  eSampledImageYcbcrConversionLinearFilter =
+      VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT,
+  eSampledImageYcbcrConversionSeparateReconstructionFilter =
+      VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT,
+  eSampledImageYcbcrConversionChromaReconstructionExplicit =
+      VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT,
+  eSampledImageYcbcrConversionChromaReconstructionExplicitForceable =
+      VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT,
+  eDisjoint = VK_FORMAT_FEATURE_DISJOINT_BIT,
+  eCositedChromaSamples = VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT,
+  eSampledImageFilterMinmax = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT,
+  eSampledImageFilterCubicIMG =
+      VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG,
+  eAccelerationStructureVertexBufferKHR =
+      VK_FORMAT_FEATURE_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR,
+  eFragmentDensityMapEXT = VK_FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT,
+  eFragmentShadingRateAttachmentKHR =
+      VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR,
+  eCositedChromaSamplesKHR = VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR,
+  eDisjointKHR = VK_FORMAT_FEATURE_DISJOINT_BIT_KHR,
+  eMidpointChromaSamplesKHR = VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR,
+  eSampledImageFilterCubicEXT =
+      VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT,
+  eSampledImageFilterMinmaxEXT =
+      VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT,
+  eSampledImageYcbcrConversionChromaReconstructionExplicitKHR =
+      VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR,
+  eSampledImageYcbcrConversionChromaReconstructionExplicitForceableKHR =
+      VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR,
+  eSampledImageYcbcrConversionLinearFilterKHR =
+      VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR,
+  eSampledImageYcbcrConversionSeparateReconstructionFilterKHR =
+      VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR,
+  eTransferDstKHR = VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR,
+  eTransferSrcKHR = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR
+};
+
+VULKAN_HPP_INLINE std::string to_string(FormatFeatureFlagBits value) {
+  switch (value) {
+  case FormatFeatureFlagBits::eSampledImage:
+    return "SampledImage";
+  case FormatFeatureFlagBits::eStorageImage:
+    return "StorageImage";
+  case FormatFeatureFlagBits::eStorageImageAtomic:
+    return "StorageImageAtomic";
+  case FormatFeatureFlagBits::eUniformTexelBuffer:
+    return "UniformTexelBuffer";
+  case FormatFeatureFlagBits::eStorageTexelBuffer:
+    return "StorageTexelBuffer";
+  case FormatFeatureFlagBits::eStorageTexelBufferAtomic:
+    return "StorageTexelBufferAtomic";
+  case FormatFeatureFlagBits::eVertexBuffer:
+    return "VertexBuffer";
+  case FormatFeatureFlagBits::eColorAttachment:
+    return "ColorAttachment";
+  case FormatFeatureFlagBits::eColorAttachmentBlend:
+    return "ColorAttachmentBlend";
+  case FormatFeatureFlagBits::eDepthStencilAttachment:
+    return "DepthStencilAttachment";
+  case FormatFeatureFlagBits::eBlitSrc:
+    return "BlitSrc";
+  case FormatFeatureFlagBits::eBlitDst:
+    return "BlitDst";
+  case FormatFeatureFlagBits::eSampledImageFilterLinear:
+    return "SampledImageFilterLinear";
+  case FormatFeatureFlagBits::eTransferSrc:
+    return "TransferSrc";
+  case FormatFeatureFlagBits::eTransferDst:
+    return "TransferDst";
+  case FormatFeatureFlagBits::eMidpointChromaSamples:
+    return "MidpointChromaSamples";
+  case FormatFeatureFlagBits::eSampledImageYcbcrConversionLinearFilter:
+    return "SampledImageYcbcrConversionLinearFilter";
+  case FormatFeatureFlagBits::
+      eSampledImageYcbcrConversionSeparateReconstructionFilter:
+    return "SampledImageYcbcrConversionSeparateReconstructionFilter";
+  case FormatFeatureFlagBits::
+      eSampledImageYcbcrConversionChromaReconstructionExplicit:
+    return "SampledImageYcbcrConversionChromaReconstructionExplicit";
+  case FormatFeatureFlagBits::
+      eSampledImageYcbcrConversionChromaReconstructionExplicitForceable:
+    return "SampledImageYcbcrConversionChromaReconstructionExplicitForceable";
+  case FormatFeatureFlagBits::eDisjoint:
+    return "Disjoint";
+  case FormatFeatureFlagBits::eCositedChromaSamples:
+    return "CositedChromaSamples";
+  case FormatFeatureFlagBits::eSampledImageFilterMinmax:
+    return "SampledImageFilterMinmax";
+  case FormatFeatureFlagBits::eSampledImageFilterCubicIMG:
+    return "SampledImageFilterCubicIMG";
+  case FormatFeatureFlagBits::eAccelerationStructureVertexBufferKHR:
+    return "AccelerationStructureVertexBufferKHR";
+  case FormatFeatureFlagBits::eFragmentDensityMapEXT:
+    return "FragmentDensityMapEXT";
+  case FormatFeatureFlagBits::eFragmentShadingRateAttachmentKHR:
+    return "FragmentShadingRateAttachmentKHR";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class ImageCreateFlagBits : VkImageCreateFlags {
+  eSparseBinding = VK_IMAGE_CREATE_SPARSE_BINDING_BIT,
+  eSparseResidency = VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT,
+  eSparseAliased = VK_IMAGE_CREATE_SPARSE_ALIASED_BIT,
+  eMutableFormat = VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT,
+  eCubeCompatible = VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT,
+  eAlias = VK_IMAGE_CREATE_ALIAS_BIT,
+  eSplitInstanceBindRegions = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT,
+  e2DArrayCompatible = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT,
+  eBlockTexelViewCompatible = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT,
+  eExtendedUsage = VK_IMAGE_CREATE_EXTENDED_USAGE_BIT,
+  eProtected = VK_IMAGE_CREATE_PROTECTED_BIT,
+  eDisjoint = VK_IMAGE_CREATE_DISJOINT_BIT,
+  eCornerSampledNV = VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV,
+  eSampleLocationsCompatibleDepthEXT =
+      VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT,
+  eSubsampledEXT = VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT,
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+  eCompactFUCHSIA = VK_IMAGE_CREATE_COMPACT_BIT_FUCHSIA,
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+  e2DArrayCompatibleKHR = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR,
+  eAliasKHR = VK_IMAGE_CREATE_ALIAS_BIT_KHR,
+  eBlockTexelViewCompatibleKHR =
+      VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR,
+  eDisjointKHR = VK_IMAGE_CREATE_DISJOINT_BIT_KHR,
+  eExtendedUsageKHR = VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR,
+  eSplitInstanceBindRegionsKHR =
+      VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR
+};
+
+VULKAN_HPP_INLINE std::string to_string(ImageCreateFlagBits value) {
+  switch (value) {
+  case ImageCreateFlagBits::eSparseBinding:
+    return "SparseBinding";
+  case ImageCreateFlagBits::eSparseResidency:
+    return "SparseResidency";
+  case ImageCreateFlagBits::eSparseAliased:
+    return "SparseAliased";
+  case ImageCreateFlagBits::eMutableFormat:
+    return "MutableFormat";
+  case ImageCreateFlagBits::eCubeCompatible:
+    return "CubeCompatible";
+  case ImageCreateFlagBits::eAlias:
+    return "Alias";
+  case ImageCreateFlagBits::eSplitInstanceBindRegions:
+    return "SplitInstanceBindRegions";
+  case ImageCreateFlagBits::e2DArrayCompatible:
+    return "2DArrayCompatible";
+  case ImageCreateFlagBits::eBlockTexelViewCompatible:
+    return "BlockTexelViewCompatible";
+  case ImageCreateFlagBits::eExtendedUsage:
+    return "ExtendedUsage";
+  case ImageCreateFlagBits::eProtected:
+    return "Protected";
+  case ImageCreateFlagBits::eDisjoint:
+    return "Disjoint";
+  case ImageCreateFlagBits::eCornerSampledNV:
+    return "CornerSampledNV";
+  case ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT:
+    return "SampleLocationsCompatibleDepthEXT";
+  case ImageCreateFlagBits::eSubsampledEXT:
+    return "SubsampledEXT";
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+  case ImageCreateFlagBits::eCompactFUCHSIA:
+    return "CompactFUCHSIA";
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class ImageTiling {
+  eOptimal = VK_IMAGE_TILING_OPTIMAL,
+  eLinear = VK_IMAGE_TILING_LINEAR,
+  eDrmFormatModifierEXT = VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT
+};
+
+VULKAN_HPP_INLINE std::string to_string(ImageTiling value) {
+  switch (value) {
+  case ImageTiling::eOptimal:
+    return "Optimal";
+  case ImageTiling::eLinear:
+    return "Linear";
+  case ImageTiling::eDrmFormatModifierEXT:
+    return "DrmFormatModifierEXT";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class ImageType {
+  e1D = VK_IMAGE_TYPE_1D,
+  e2D = VK_IMAGE_TYPE_2D,
+  e3D = VK_IMAGE_TYPE_3D
+};
+
+VULKAN_HPP_INLINE std::string to_string(ImageType value) {
+  switch (value) {
+  case ImageType::e1D:
+    return "1D";
+  case ImageType::e2D:
+    return "2D";
+  case ImageType::e3D:
+    return "3D";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class ImageUsageFlagBits : VkImageUsageFlags {
+  eTransferSrc = VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
+  eTransferDst = VK_IMAGE_USAGE_TRANSFER_DST_BIT,
+  eSampled = VK_IMAGE_USAGE_SAMPLED_BIT,
+  eStorage = VK_IMAGE_USAGE_STORAGE_BIT,
+  eColorAttachment = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
+  eDepthStencilAttachment = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
+  eTransientAttachment = VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT,
+  eInputAttachment = VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT,
+  eShadingRateImageNV = VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV,
+  eFragmentDensityMapEXT = VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT,
+  eFragmentShadingRateAttachmentKHR =
+      VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR
+};
+
+VULKAN_HPP_INLINE std::string to_string(ImageUsageFlagBits value) {
+  switch (value) {
+  case ImageUsageFlagBits::eTransferSrc:
+    return "TransferSrc";
+  case ImageUsageFlagBits::eTransferDst:
+    return "TransferDst";
+  case ImageUsageFlagBits::eSampled:
+    return "Sampled";
+  case ImageUsageFlagBits::eStorage:
+    return "Storage";
+  case ImageUsageFlagBits::eColorAttachment:
+    return "ColorAttachment";
+  case ImageUsageFlagBits::eDepthStencilAttachment:
+    return "DepthStencilAttachment";
+  case ImageUsageFlagBits::eTransientAttachment:
+    return "TransientAttachment";
+  case ImageUsageFlagBits::eInputAttachment:
+    return "InputAttachment";
+  case ImageUsageFlagBits::eShadingRateImageNV:
+    return "ShadingRateImageNV";
+  case ImageUsageFlagBits::eFragmentDensityMapEXT:
+    return "FragmentDensityMapEXT";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class InstanceCreateFlagBits {};
+
+VULKAN_HPP_INLINE std::string to_string(InstanceCreateFlagBits) {
+  return "(void)";
+}
+
+enum class InternalAllocationType {
+  eExecutable = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE
+};
+
+VULKAN_HPP_INLINE std::string to_string(InternalAllocationType value) {
+  switch (value) {
+  case InternalAllocationType::eExecutable:
+    return "Executable";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class MemoryHeapFlagBits : VkMemoryHeapFlags {
+  eDeviceLocal = VK_MEMORY_HEAP_DEVICE_LOCAL_BIT,
+  eMultiInstance = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT,
+  eMultiInstanceKHR = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHR
+};
+
+VULKAN_HPP_INLINE std::string to_string(MemoryHeapFlagBits value) {
+  switch (value) {
+  case MemoryHeapFlagBits::eDeviceLocal:
+    return "DeviceLocal";
+  case MemoryHeapFlagBits::eMultiInstance:
+    return "MultiInstance";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class MemoryPropertyFlagBits : VkMemoryPropertyFlags {
+  eDeviceLocal = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
+  eHostVisible = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
+  eHostCoherent = VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
+  eHostCached = VK_MEMORY_PROPERTY_HOST_CACHED_BIT,
+  eLazilyAllocated = VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT,
+  eProtected = VK_MEMORY_PROPERTY_PROTECTED_BIT,
+  eDeviceCoherentAMD = VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD,
+  eDeviceUncachedAMD = VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD
+};
+
+VULKAN_HPP_INLINE std::string to_string(MemoryPropertyFlagBits value) {
+  switch (value) {
+  case MemoryPropertyFlagBits::eDeviceLocal:
+    return "DeviceLocal";
+  case MemoryPropertyFlagBits::eHostVisible:
+    return "HostVisible";
+  case MemoryPropertyFlagBits::eHostCoherent:
+    return "HostCoherent";
+  case MemoryPropertyFlagBits::eHostCached:
+    return "HostCached";
+  case MemoryPropertyFlagBits::eLazilyAllocated:
+    return "LazilyAllocated";
+  case MemoryPropertyFlagBits::eProtected:
+    return "Protected";
+  case MemoryPropertyFlagBits::eDeviceCoherentAMD:
+    return "DeviceCoherentAMD";
+  case MemoryPropertyFlagBits::eDeviceUncachedAMD:
+    return "DeviceUncachedAMD";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class PhysicalDeviceType {
+  eOther = VK_PHYSICAL_DEVICE_TYPE_OTHER,
+  eIntegratedGpu = VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU,
+  eDiscreteGpu = VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU,
+  eVirtualGpu = VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU,
+  eCpu = VK_PHYSICAL_DEVICE_TYPE_CPU
+};
+
+VULKAN_HPP_INLINE std::string to_string(PhysicalDeviceType value) {
+  switch (value) {
+  case PhysicalDeviceType::eOther:
+    return "Other";
+  case PhysicalDeviceType::eIntegratedGpu:
+    return "IntegratedGpu";
+  case PhysicalDeviceType::eDiscreteGpu:
+    return "DiscreteGpu";
+  case PhysicalDeviceType::eVirtualGpu:
+    return "VirtualGpu";
+  case PhysicalDeviceType::eCpu:
+    return "Cpu";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class QueueFlagBits : VkQueueFlags {
+  eGraphics = VK_QUEUE_GRAPHICS_BIT,
+  eCompute = VK_QUEUE_COMPUTE_BIT,
+  eTransfer = VK_QUEUE_TRANSFER_BIT,
+  eSparseBinding = VK_QUEUE_SPARSE_BINDING_BIT,
+  eProtected = VK_QUEUE_PROTECTED_BIT
+};
+
+VULKAN_HPP_INLINE std::string to_string(QueueFlagBits value) {
+  switch (value) {
+  case QueueFlagBits::eGraphics:
+    return "Graphics";
+  case QueueFlagBits::eCompute:
+    return "Compute";
+  case QueueFlagBits::eTransfer:
+    return "Transfer";
+  case QueueFlagBits::eSparseBinding:
+    return "SparseBinding";
+  case QueueFlagBits::eProtected:
+    return "Protected";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class SampleCountFlagBits : VkSampleCountFlags {
+  e1 = VK_SAMPLE_COUNT_1_BIT,
+  e2 = VK_SAMPLE_COUNT_2_BIT,
+  e4 = VK_SAMPLE_COUNT_4_BIT,
+  e8 = VK_SAMPLE_COUNT_8_BIT,
+  e16 = VK_SAMPLE_COUNT_16_BIT,
+  e32 = VK_SAMPLE_COUNT_32_BIT,
+  e64 = VK_SAMPLE_COUNT_64_BIT
+};
+
+VULKAN_HPP_INLINE std::string to_string(SampleCountFlagBits value) {
+  switch (value) {
+  case SampleCountFlagBits::e1:
+    return "1";
+  case SampleCountFlagBits::e2:
+    return "2";
+  case SampleCountFlagBits::e4:
+    return "4";
+  case SampleCountFlagBits::e8:
+    return "8";
+  case SampleCountFlagBits::e16:
+    return "16";
+  case SampleCountFlagBits::e32:
+    return "32";
+  case SampleCountFlagBits::e64:
+    return "64";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class SystemAllocationScope {
+  eCommand = VK_SYSTEM_ALLOCATION_SCOPE_COMMAND,
+  eObject = VK_SYSTEM_ALLOCATION_SCOPE_OBJECT,
+  eCache = VK_SYSTEM_ALLOCATION_SCOPE_CACHE,
+  eDevice = VK_SYSTEM_ALLOCATION_SCOPE_DEVICE,
+  eInstance = VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE
+};
+
+VULKAN_HPP_INLINE std::string to_string(SystemAllocationScope value) {
+  switch (value) {
+  case SystemAllocationScope::eCommand:
+    return "Command";
+  case SystemAllocationScope::eObject:
+    return "Object";
+  case SystemAllocationScope::eCache:
+    return "Cache";
+  case SystemAllocationScope::eDevice:
+    return "Device";
+  case SystemAllocationScope::eInstance:
+    return "Instance";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class DeviceCreateFlagBits {};
+
+VULKAN_HPP_INLINE std::string to_string(DeviceCreateFlagBits) {
+  return "(void)";
+}
+
+enum class DeviceQueueCreateFlagBits : VkDeviceQueueCreateFlags {
+  eProtected = VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT
+};
+
+VULKAN_HPP_INLINE std::string to_string(DeviceQueueCreateFlagBits value) {
+  switch (value) {
+  case DeviceQueueCreateFlagBits::eProtected:
+    return "Protected";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class PipelineStageFlagBits : VkPipelineStageFlags {
+  eTopOfPipe = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
+  eDrawIndirect = VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT,
+  eVertexInput = VK_PIPELINE_STAGE_VERTEX_INPUT_BIT,
+  eVertexShader = VK_PIPELINE_STAGE_VERTEX_SHADER_BIT,
+  eTessellationControlShader =
+      VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT,
+  eTessellationEvaluationShader =
+      VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT,
+  eGeometryShader = VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT,
+  eFragmentShader = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
+  eEarlyFragmentTests = VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT,
+  eLateFragmentTests = VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
+  eColorAttachmentOutput = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
+  eComputeShader = VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
+  eTransfer = VK_PIPELINE_STAGE_TRANSFER_BIT,
+  eBottomOfPipe = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
+  eHost = VK_PIPELINE_STAGE_HOST_BIT,
+  eAllGraphics = VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT,
+  eAllCommands = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
+  eTransformFeedbackEXT = VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT,
+  eConditionalRenderingEXT = VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT,
+  eAccelerationStructureBuildKHR =
+      VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR,
+  eRayTracingShaderKHR = VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR,
+  eShadingRateImageNV = VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV,
+  eTaskShaderNV = VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV,
+  eMeshShaderNV = VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV,
+  eFragmentDensityProcessEXT =
+      VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT,
+  eCommandPreprocessNV = VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_NV,
+  eNoneKHR = VK_PIPELINE_STAGE_NONE_KHR,
+  eAccelerationStructureBuildNV =
+      VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_NV,
+  eFragmentShadingRateAttachmentKHR =
+      VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR,
+  eRayTracingShaderNV = VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_NV
+};
+
+VULKAN_HPP_INLINE std::string to_string(PipelineStageFlagBits value) {
+  switch (value) {
+  case PipelineStageFlagBits::eTopOfPipe:
+    return "TopOfPipe";
+  case PipelineStageFlagBits::eDrawIndirect:
+    return "DrawIndirect";
+  case PipelineStageFlagBits::eVertexInput:
+    return "VertexInput";
+  case PipelineStageFlagBits::eVertexShader:
+    return "VertexShader";
+  case PipelineStageFlagBits::eTessellationControlShader:
+    return "TessellationControlShader";
+  case PipelineStageFlagBits::eTessellationEvaluationShader:
+    return "TessellationEvaluationShader";
+  case PipelineStageFlagBits::eGeometryShader:
+    return "GeometryShader";
+  case PipelineStageFlagBits::eFragmentShader:
+    return "FragmentShader";
+  case PipelineStageFlagBits::eEarlyFragmentTests:
+    return "EarlyFragmentTests";
+  case PipelineStageFlagBits::eLateFragmentTests:
+    return "LateFragmentTests";
+  case PipelineStageFlagBits::eColorAttachmentOutput:
+    return "ColorAttachmentOutput";
+  case PipelineStageFlagBits::eComputeShader:
+    return "ComputeShader";
+  case PipelineStageFlagBits::eTransfer:
+    return "Transfer";
+  case PipelineStageFlagBits::eBottomOfPipe:
+    return "BottomOfPipe";
+  case PipelineStageFlagBits::eHost:
+    return "Host";
+  case PipelineStageFlagBits::eAllGraphics:
+    return "AllGraphics";
+  case PipelineStageFlagBits::eAllCommands:
+    return "AllCommands";
+  case PipelineStageFlagBits::eTransformFeedbackEXT:
+    return "TransformFeedbackEXT";
+  case PipelineStageFlagBits::eConditionalRenderingEXT:
+    return "ConditionalRenderingEXT";
+  case PipelineStageFlagBits::eAccelerationStructureBuildKHR:
+    return "AccelerationStructureBuildKHR";
+  case PipelineStageFlagBits::eRayTracingShaderKHR:
+    return "RayTracingShaderKHR";
+  case PipelineStageFlagBits::eShadingRateImageNV:
+    return "ShadingRateImageNV";
+  case PipelineStageFlagBits::eTaskShaderNV:
+    return "TaskShaderNV";
+  case PipelineStageFlagBits::eMeshShaderNV:
+    return "MeshShaderNV";
+  case PipelineStageFlagBits::eFragmentDensityProcessEXT:
+    return "FragmentDensityProcessEXT";
+  case PipelineStageFlagBits::eCommandPreprocessNV:
+    return "CommandPreprocessNV";
+  case PipelineStageFlagBits::eNoneKHR:
+    return "NoneKHR";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class ImageAspectFlagBits : VkImageAspectFlags {
+  eColor = VK_IMAGE_ASPECT_COLOR_BIT,
+  eDepth = VK_IMAGE_ASPECT_DEPTH_BIT,
+  eStencil = VK_IMAGE_ASPECT_STENCIL_BIT,
+  eMetadata = VK_IMAGE_ASPECT_METADATA_BIT,
+  ePlane0 = VK_IMAGE_ASPECT_PLANE_0_BIT,
+  ePlane1 = VK_IMAGE_ASPECT_PLANE_1_BIT,
+  ePlane2 = VK_IMAGE_ASPECT_PLANE_2_BIT,
+  eMemoryPlane0EXT = VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT,
+  eMemoryPlane1EXT = VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT,
+  eMemoryPlane2EXT = VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT,
+  eMemoryPlane3EXT = VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT,
+  ePlane0KHR = VK_IMAGE_ASPECT_PLANE_0_BIT_KHR,
+  ePlane1KHR = VK_IMAGE_ASPECT_PLANE_1_BIT_KHR,
+  ePlane2KHR = VK_IMAGE_ASPECT_PLANE_2_BIT_KHR
+};
+
+VULKAN_HPP_INLINE std::string to_string(ImageAspectFlagBits value) {
+  switch (value) {
+  case ImageAspectFlagBits::eColor:
+    return "Color";
+  case ImageAspectFlagBits::eDepth:
+    return "Depth";
+  case ImageAspectFlagBits::eStencil:
+    return "Stencil";
+  case ImageAspectFlagBits::eMetadata:
+    return "Metadata";
+  case ImageAspectFlagBits::ePlane0:
+    return "Plane0";
+  case ImageAspectFlagBits::ePlane1:
+    return "Plane1";
+  case ImageAspectFlagBits::ePlane2:
+    return "Plane2";
+  case ImageAspectFlagBits::eMemoryPlane0EXT:
+    return "MemoryPlane0EXT";
+  case ImageAspectFlagBits::eMemoryPlane1EXT:
+    return "MemoryPlane1EXT";
+  case ImageAspectFlagBits::eMemoryPlane2EXT:
+    return "MemoryPlane2EXT";
+  case ImageAspectFlagBits::eMemoryPlane3EXT:
+    return "MemoryPlane3EXT";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class SparseImageFormatFlagBits : VkSparseImageFormatFlags {
+  eSingleMiptail = VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT,
+  eAlignedMipSize = VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT,
+  eNonstandardBlockSize = VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT
+};
+
+VULKAN_HPP_INLINE std::string to_string(SparseImageFormatFlagBits value) {
+  switch (value) {
+  case SparseImageFormatFlagBits::eSingleMiptail:
+    return "SingleMiptail";
+  case SparseImageFormatFlagBits::eAlignedMipSize:
+    return "AlignedMipSize";
+  case SparseImageFormatFlagBits::eNonstandardBlockSize:
+    return "NonstandardBlockSize";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class SparseMemoryBindFlagBits : VkSparseMemoryBindFlags {
+  eMetadata = VK_SPARSE_MEMORY_BIND_METADATA_BIT
+};
+
+VULKAN_HPP_INLINE std::string to_string(SparseMemoryBindFlagBits value) {
+  switch (value) {
+  case SparseMemoryBindFlagBits::eMetadata:
+    return "Metadata";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class FenceCreateFlagBits : VkFenceCreateFlags {
+  eSignaled = VK_FENCE_CREATE_SIGNALED_BIT
+};
+
+VULKAN_HPP_INLINE std::string to_string(FenceCreateFlagBits value) {
+  switch (value) {
+  case FenceCreateFlagBits::eSignaled:
+    return "Signaled";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class EventCreateFlagBits : VkEventCreateFlags {
+  eDeviceOnlyKHR = VK_EVENT_CREATE_DEVICE_ONLY_BIT_KHR
+};
+
+VULKAN_HPP_INLINE std::string to_string(EventCreateFlagBits value) {
+  switch (value) {
+  case EventCreateFlagBits::eDeviceOnlyKHR:
+    return "DeviceOnlyKHR";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class QueryPipelineStatisticFlagBits : VkQueryPipelineStatisticFlags {
+  eInputAssemblyVertices =
+      VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT,
+  eInputAssemblyPrimitives =
+      VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT,
+  eVertexShaderInvocations =
+      VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT,
+  eGeometryShaderInvocations =
+      VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT,
+  eGeometryShaderPrimitives =
+      VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT,
+  eClippingInvocations = VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT,
+  eClippingPrimitives = VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT,
+  eFragmentShaderInvocations =
+      VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT,
+  eTessellationControlShaderPatches =
+      VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT,
+  eTessellationEvaluationShaderInvocations =
+      VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT,
+  eComputeShaderInvocations =
+      VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT
+};
+
+VULKAN_HPP_INLINE std::string to_string(QueryPipelineStatisticFlagBits value) {
+  switch (value) {
+  case QueryPipelineStatisticFlagBits::eInputAssemblyVertices:
+    return "InputAssemblyVertices";
+  case QueryPipelineStatisticFlagBits::eInputAssemblyPrimitives:
+    return "InputAssemblyPrimitives";
+  case QueryPipelineStatisticFlagBits::eVertexShaderInvocations:
+    return "VertexShaderInvocations";
+  case QueryPipelineStatisticFlagBits::eGeometryShaderInvocations:
+    return "GeometryShaderInvocations";
+  case QueryPipelineStatisticFlagBits::eGeometryShaderPrimitives:
+    return "GeometryShaderPrimitives";
+  case QueryPipelineStatisticFlagBits::eClippingInvocations:
+    return "ClippingInvocations";
+  case QueryPipelineStatisticFlagBits::eClippingPrimitives:
+    return "ClippingPrimitives";
+  case QueryPipelineStatisticFlagBits::eFragmentShaderInvocations:
+    return "FragmentShaderInvocations";
+  case QueryPipelineStatisticFlagBits::eTessellationControlShaderPatches:
+    return "TessellationControlShaderPatches";
+  case QueryPipelineStatisticFlagBits::eTessellationEvaluationShaderInvocations:
+    return "TessellationEvaluationShaderInvocations";
+  case QueryPipelineStatisticFlagBits::eComputeShaderInvocations:
+    return "ComputeShaderInvocations";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class QueryPoolCreateFlagBits {};
+
+VULKAN_HPP_INLINE std::string to_string(QueryPoolCreateFlagBits) {
+  return "(void)";
+}
+
+enum class QueryResultFlagBits : VkQueryResultFlags {
+  e64 = VK_QUERY_RESULT_64_BIT,
+  eWait = VK_QUERY_RESULT_WAIT_BIT,
+  eWithAvailability = VK_QUERY_RESULT_WITH_AVAILABILITY_BIT,
+  ePartial = VK_QUERY_RESULT_PARTIAL_BIT
+};
+
+VULKAN_HPP_INLINE std::string to_string(QueryResultFlagBits value) {
+  switch (value) {
+  case QueryResultFlagBits::e64:
+    return "64";
+  case QueryResultFlagBits::eWait:
+    return "Wait";
+  case QueryResultFlagBits::eWithAvailability:
+    return "WithAvailability";
+  case QueryResultFlagBits::ePartial:
+    return "Partial";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class QueryType {
+  eOcclusion = VK_QUERY_TYPE_OCCLUSION,
+  ePipelineStatistics = VK_QUERY_TYPE_PIPELINE_STATISTICS,
+  eTimestamp = VK_QUERY_TYPE_TIMESTAMP,
+  eTransformFeedbackStreamEXT = VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT,
+  ePerformanceQueryKHR = VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR,
+  eAccelerationStructureCompactedSizeKHR =
+      VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR,
+  eAccelerationStructureSerializationSizeKHR =
+      VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR,
+  eAccelerationStructureCompactedSizeNV =
+      VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV,
+  ePerformanceQueryINTEL = VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL
+};
+
+VULKAN_HPP_INLINE std::string to_string(QueryType value) {
+  switch (value) {
+  case QueryType::eOcclusion:
+    return "Occlusion";
+  case QueryType::ePipelineStatistics:
+    return "PipelineStatistics";
+  case QueryType::eTimestamp:
+    return "Timestamp";
+  case QueryType::eTransformFeedbackStreamEXT:
+    return "TransformFeedbackStreamEXT";
+  case QueryType::ePerformanceQueryKHR:
+    return "PerformanceQueryKHR";
+  case QueryType::eAccelerationStructureCompactedSizeKHR:
+    return "AccelerationStructureCompactedSizeKHR";
+  case QueryType::eAccelerationStructureSerializationSizeKHR:
+    return "AccelerationStructureSerializationSizeKHR";
+  case QueryType::eAccelerationStructureCompactedSizeNV:
+    return "AccelerationStructureCompactedSizeNV";
+  case QueryType::ePerformanceQueryINTEL:
+    return "PerformanceQueryINTEL";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class BufferCreateFlagBits : VkBufferCreateFlags {
+  eSparseBinding = VK_BUFFER_CREATE_SPARSE_BINDING_BIT,
+  eSparseResidency = VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT,
+  eSparseAliased = VK_BUFFER_CREATE_SPARSE_ALIASED_BIT,
+  eProtected = VK_BUFFER_CREATE_PROTECTED_BIT,
+  eDeviceAddressCaptureReplay =
+      VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT,
+  eDeviceAddressCaptureReplayEXT =
+      VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT,
+  eDeviceAddressCaptureReplayKHR =
+      VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR
+};
+
+VULKAN_HPP_INLINE std::string to_string(BufferCreateFlagBits value) {
+  switch (value) {
+  case BufferCreateFlagBits::eSparseBinding:
+    return "SparseBinding";
+  case BufferCreateFlagBits::eSparseResidency:
+    return "SparseResidency";
+  case BufferCreateFlagBits::eSparseAliased:
+    return "SparseAliased";
+  case BufferCreateFlagBits::eProtected:
+    return "Protected";
+  case BufferCreateFlagBits::eDeviceAddressCaptureReplay:
+    return "DeviceAddressCaptureReplay";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class BufferUsageFlagBits : VkBufferUsageFlags {
+  eTransferSrc = VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
+  eTransferDst = VK_BUFFER_USAGE_TRANSFER_DST_BIT,
+  eUniformTexelBuffer = VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT,
+  eStorageTexelBuffer = VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT,
+  eUniformBuffer = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
+  eStorageBuffer = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT,
+  eIndexBuffer = VK_BUFFER_USAGE_INDEX_BUFFER_BIT,
+  eVertexBuffer = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
+  eIndirectBuffer = VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT,
+  eShaderDeviceAddress = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
+  eTransformFeedbackBufferEXT =
+      VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT,
+  eTransformFeedbackCounterBufferEXT =
+      VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT,
+  eConditionalRenderingEXT = VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT,
+  eAccelerationStructureBuildInputReadOnlyKHR =
+      VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR,
+  eAccelerationStructureStorageKHR =
+      VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR,
+  eShaderBindingTableKHR = VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR,
+  eRayTracingNV = VK_BUFFER_USAGE_RAY_TRACING_BIT_NV,
+  eShaderDeviceAddressEXT = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT,
+  eShaderDeviceAddressKHR = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR
+};
+
+VULKAN_HPP_INLINE std::string to_string(BufferUsageFlagBits value) {
+  switch (value) {
+  case BufferUsageFlagBits::eTransferSrc:
+    return "TransferSrc";
+  case BufferUsageFlagBits::eTransferDst:
+    return "TransferDst";
+  case BufferUsageFlagBits::eUniformTexelBuffer:
+    return "UniformTexelBuffer";
+  case BufferUsageFlagBits::eStorageTexelBuffer:
+    return "StorageTexelBuffer";
+  case BufferUsageFlagBits::eUniformBuffer:
+    return "UniformBuffer";
+  case BufferUsageFlagBits::eStorageBuffer:
+    return "StorageBuffer";
+  case BufferUsageFlagBits::eIndexBuffer:
+    return "IndexBuffer";
+  case BufferUsageFlagBits::eVertexBuffer:
+    return "VertexBuffer";
+  case BufferUsageFlagBits::eIndirectBuffer:
+    return "IndirectBuffer";
+  case BufferUsageFlagBits::eShaderDeviceAddress:
+    return "ShaderDeviceAddress";
+  case BufferUsageFlagBits::eTransformFeedbackBufferEXT:
+    return "TransformFeedbackBufferEXT";
+  case BufferUsageFlagBits::eTransformFeedbackCounterBufferEXT:
+    return "TransformFeedbackCounterBufferEXT";
+  case BufferUsageFlagBits::eConditionalRenderingEXT:
+    return "ConditionalRenderingEXT";
+  case BufferUsageFlagBits::eAccelerationStructureBuildInputReadOnlyKHR:
+    return "AccelerationStructureBuildInputReadOnlyKHR";
+  case BufferUsageFlagBits::eAccelerationStructureStorageKHR:
+    return "AccelerationStructureStorageKHR";
+  case BufferUsageFlagBits::eShaderBindingTableKHR:
+    return "ShaderBindingTableKHR";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class SharingMode {
+  eExclusive = VK_SHARING_MODE_EXCLUSIVE,
+  eConcurrent = VK_SHARING_MODE_CONCURRENT
+};
+
+VULKAN_HPP_INLINE std::string to_string(SharingMode value) {
+  switch (value) {
+  case SharingMode::eExclusive:
+    return "Exclusive";
+  case SharingMode::eConcurrent:
+    return "Concurrent";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class ImageLayout {
+  eUndefined = VK_IMAGE_LAYOUT_UNDEFINED,
+  eGeneral = VK_IMAGE_LAYOUT_GENERAL,
+  eColorAttachmentOptimal = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+  eDepthStencilAttachmentOptimal =
+      VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
+  eDepthStencilReadOnlyOptimal =
+      VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL,
+  eShaderReadOnlyOptimal = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
+  eTransferSrcOptimal = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
+  eTransferDstOptimal = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+  ePreinitialized = VK_IMAGE_LAYOUT_PREINITIALIZED,
+  eDepthReadOnlyStencilAttachmentOptimal =
+      VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL,
+  eDepthAttachmentStencilReadOnlyOptimal =
+      VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL,
+  eDepthAttachmentOptimal = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL,
+  eDepthReadOnlyOptimal = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL,
+  eStencilAttachmentOptimal = VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL,
+  eStencilReadOnlyOptimal = VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL,
+  ePresentSrcKHR = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
+  eSharedPresentKHR = VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR,
+  eShadingRateOptimalNV = VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV,
+  eFragmentDensityMapOptimalEXT =
+      VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT,
+  eReadOnlyOptimalKHR = VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL_KHR,
+  eAttachmentOptimalKHR = VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR,
+  eDepthAttachmentOptimalKHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL_KHR,
+  eDepthAttachmentStencilReadOnlyOptimalKHR =
+      VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR,
+  eDepthReadOnlyOptimalKHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL_KHR,
+  eDepthReadOnlyStencilAttachmentOptimalKHR =
+      VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR,
+  eFragmentShadingRateAttachmentOptimalKHR =
+      VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR,
+  eStencilAttachmentOptimalKHR = VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL_KHR,
+  eStencilReadOnlyOptimalKHR = VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL_KHR
+};
+
+VULKAN_HPP_INLINE std::string to_string(ImageLayout value) {
+  switch (value) {
+  case ImageLayout::eUndefined:
+    return "Undefined";
+  case ImageLayout::eGeneral:
+    return "General";
+  case ImageLayout::eColorAttachmentOptimal:
+    return "ColorAttachmentOptimal";
+  case ImageLayout::eDepthStencilAttachmentOptimal:
+    return "DepthStencilAttachmentOptimal";
+  case ImageLayout::eDepthStencilReadOnlyOptimal:
+    return "DepthStencilReadOnlyOptimal";
+  case ImageLayout::eShaderReadOnlyOptimal:
+    return "ShaderReadOnlyOptimal";
+  case ImageLayout::eTransferSrcOptimal:
+    return "TransferSrcOptimal";
+  case ImageLayout::eTransferDstOptimal:
+    return "TransferDstOptimal";
+  case ImageLayout::ePreinitialized:
+    return "Preinitialized";
+  case ImageLayout::eDepthReadOnlyStencilAttachmentOptimal:
+    return "DepthReadOnlyStencilAttachmentOptimal";
+  case ImageLayout::eDepthAttachmentStencilReadOnlyOptimal:
+    return "DepthAttachmentStencilReadOnlyOptimal";
+  case ImageLayout::eDepthAttachmentOptimal:
+    return "DepthAttachmentOptimal";
+  case ImageLayout::eDepthReadOnlyOptimal:
+    return "DepthReadOnlyOptimal";
+  case ImageLayout::eStencilAttachmentOptimal:
+    return "StencilAttachmentOptimal";
+  case ImageLayout::eStencilReadOnlyOptimal:
+    return "StencilReadOnlyOptimal";
+  case ImageLayout::ePresentSrcKHR:
+    return "PresentSrcKHR";
+  case ImageLayout::eSharedPresentKHR:
+    return "SharedPresentKHR";
+  case ImageLayout::eShadingRateOptimalNV:
+    return "ShadingRateOptimalNV";
+  case ImageLayout::eFragmentDensityMapOptimalEXT:
+    return "FragmentDensityMapOptimalEXT";
+  case ImageLayout::eReadOnlyOptimalKHR:
+    return "ReadOnlyOptimalKHR";
+  case ImageLayout::eAttachmentOptimalKHR:
+    return "AttachmentOptimalKHR";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class ComponentSwizzle {
+  eIdentity = VK_COMPONENT_SWIZZLE_IDENTITY,
+  eZero = VK_COMPONENT_SWIZZLE_ZERO,
+  eOne = VK_COMPONENT_SWIZZLE_ONE,
+  eR = VK_COMPONENT_SWIZZLE_R,
+  eG = VK_COMPONENT_SWIZZLE_G,
+  eB = VK_COMPONENT_SWIZZLE_B,
+  eA = VK_COMPONENT_SWIZZLE_A
+};
+
+VULKAN_HPP_INLINE std::string to_string(ComponentSwizzle value) {
+  switch (value) {
+  case ComponentSwizzle::eIdentity:
+    return "Identity";
+  case ComponentSwizzle::eZero:
+    return "Zero";
+  case ComponentSwizzle::eOne:
+    return "One";
+  case ComponentSwizzle::eR:
+    return "R";
+  case ComponentSwizzle::eG:
+    return "G";
+  case ComponentSwizzle::eB:
+    return "B";
+  case ComponentSwizzle::eA:
+    return "A";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class ImageViewCreateFlagBits : VkImageViewCreateFlags {
+  eFragmentDensityMapDynamicEXT =
+      VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT,
+  eFragmentDensityMapDeferredEXT =
+      VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DEFERRED_BIT_EXT
+};
+
+VULKAN_HPP_INLINE std::string to_string(ImageViewCreateFlagBits value) {
+  switch (value) {
+  case ImageViewCreateFlagBits::eFragmentDensityMapDynamicEXT:
+    return "FragmentDensityMapDynamicEXT";
+  case ImageViewCreateFlagBits::eFragmentDensityMapDeferredEXT:
+    return "FragmentDensityMapDeferredEXT";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class ImageViewType {
+  e1D = VK_IMAGE_VIEW_TYPE_1D,
+  e2D = VK_IMAGE_VIEW_TYPE_2D,
+  e3D = VK_IMAGE_VIEW_TYPE_3D,
+  eCube = VK_IMAGE_VIEW_TYPE_CUBE,
+  e1DArray = VK_IMAGE_VIEW_TYPE_1D_ARRAY,
+  e2DArray = VK_IMAGE_VIEW_TYPE_2D_ARRAY,
+  eCubeArray = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY
+};
+
+VULKAN_HPP_INLINE std::string to_string(ImageViewType value) {
+  switch (value) {
+  case ImageViewType::e1D:
+    return "1D";
+  case ImageViewType::e2D:
+    return "2D";
+  case ImageViewType::e3D:
+    return "3D";
+  case ImageViewType::eCube:
+    return "Cube";
+  case ImageViewType::e1DArray:
+    return "1DArray";
+  case ImageViewType::e2DArray:
+    return "2DArray";
+  case ImageViewType::eCubeArray:
+    return "CubeArray";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class ShaderModuleCreateFlagBits : VkShaderModuleCreateFlags {};
+
+VULKAN_HPP_INLINE std::string to_string(ShaderModuleCreateFlagBits) {
+  return "(void)";
+}
+
+enum class PipelineCacheCreateFlagBits : VkPipelineCacheCreateFlags {
+  eExternallySynchronizedEXT =
+      VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT
+};
+
+VULKAN_HPP_INLINE std::string to_string(PipelineCacheCreateFlagBits value) {
+  switch (value) {
+  case PipelineCacheCreateFlagBits::eExternallySynchronizedEXT:
+    return "ExternallySynchronizedEXT";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class BlendFactor {
+  eZero = VK_BLEND_FACTOR_ZERO,
+  eOne = VK_BLEND_FACTOR_ONE,
+  eSrcColor = VK_BLEND_FACTOR_SRC_COLOR,
+  eOneMinusSrcColor = VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR,
+  eDstColor = VK_BLEND_FACTOR_DST_COLOR,
+  eOneMinusDstColor = VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR,
+  eSrcAlpha = VK_BLEND_FACTOR_SRC_ALPHA,
+  eOneMinusSrcAlpha = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,
+  eDstAlpha = VK_BLEND_FACTOR_DST_ALPHA,
+  eOneMinusDstAlpha = VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA,
+  eConstantColor = VK_BLEND_FACTOR_CONSTANT_COLOR,
+  eOneMinusConstantColor = VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR,
+  eConstantAlpha = VK_BLEND_FACTOR_CONSTANT_ALPHA,
+  eOneMinusConstantAlpha = VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA,
+  eSrcAlphaSaturate = VK_BLEND_FACTOR_SRC_ALPHA_SATURATE,
+  eSrc1Color = VK_BLEND_FACTOR_SRC1_COLOR,
+  eOneMinusSrc1Color = VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR,
+  eSrc1Alpha = VK_BLEND_FACTOR_SRC1_ALPHA,
+  eOneMinusSrc1Alpha = VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA
+};
+
+VULKAN_HPP_INLINE std::string to_string(BlendFactor value) {
+  switch (value) {
+  case BlendFactor::eZero:
+    return "Zero";
+  case BlendFactor::eOne:
+    return "One";
+  case BlendFactor::eSrcColor:
+    return "SrcColor";
+  case BlendFactor::eOneMinusSrcColor:
+    return "OneMinusSrcColor";
+  case BlendFactor::eDstColor:
+    return "DstColor";
+  case BlendFactor::eOneMinusDstColor:
+    return "OneMinusDstColor";
+  case BlendFactor::eSrcAlpha:
+    return "SrcAlpha";
+  case BlendFactor::eOneMinusSrcAlpha:
+    return "OneMinusSrcAlpha";
+  case BlendFactor::eDstAlpha:
+    return "DstAlpha";
+  case BlendFactor::eOneMinusDstAlpha:
+    return "OneMinusDstAlpha";
+  case BlendFactor::eConstantColor:
+    return "ConstantColor";
+  case BlendFactor::eOneMinusConstantColor:
+    return "OneMinusConstantColor";
+  case BlendFactor::eConstantAlpha:
+    return "ConstantAlpha";
+  case BlendFactor::eOneMinusConstantAlpha:
+    return "OneMinusConstantAlpha";
+  case BlendFactor::eSrcAlphaSaturate:
+    return "SrcAlphaSaturate";
+  case BlendFactor::eSrc1Color:
+    return "Src1Color";
+  case BlendFactor::eOneMinusSrc1Color:
+    return "OneMinusSrc1Color";
+  case BlendFactor::eSrc1Alpha:
+    return "Src1Alpha";
+  case BlendFactor::eOneMinusSrc1Alpha:
+    return "OneMinusSrc1Alpha";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class BlendOp {
+  eAdd = VK_BLEND_OP_ADD,
+  eSubtract = VK_BLEND_OP_SUBTRACT,
+  eReverseSubtract = VK_BLEND_OP_REVERSE_SUBTRACT,
+  eMin = VK_BLEND_OP_MIN,
+  eMax = VK_BLEND_OP_MAX,
+  eZeroEXT = VK_BLEND_OP_ZERO_EXT,
+  eSrcEXT = VK_BLEND_OP_SRC_EXT,
+  eDstEXT = VK_BLEND_OP_DST_EXT,
+  eSrcOverEXT = VK_BLEND_OP_SRC_OVER_EXT,
+  eDstOverEXT = VK_BLEND_OP_DST_OVER_EXT,
+  eSrcInEXT = VK_BLEND_OP_SRC_IN_EXT,
+  eDstInEXT = VK_BLEND_OP_DST_IN_EXT,
+  eSrcOutEXT = VK_BLEND_OP_SRC_OUT_EXT,
+  eDstOutEXT = VK_BLEND_OP_DST_OUT_EXT,
+  eSrcAtopEXT = VK_BLEND_OP_SRC_ATOP_EXT,
+  eDstAtopEXT = VK_BLEND_OP_DST_ATOP_EXT,
+  eXorEXT = VK_BLEND_OP_XOR_EXT,
+  eMultiplyEXT = VK_BLEND_OP_MULTIPLY_EXT,
+  eScreenEXT = VK_BLEND_OP_SCREEN_EXT,
+  eOverlayEXT = VK_BLEND_OP_OVERLAY_EXT,
+  eDarkenEXT = VK_BLEND_OP_DARKEN_EXT,
+  eLightenEXT = VK_BLEND_OP_LIGHTEN_EXT,
+  eColordodgeEXT = VK_BLEND_OP_COLORDODGE_EXT,
+  eColorburnEXT = VK_BLEND_OP_COLORBURN_EXT,
+  eHardlightEXT = VK_BLEND_OP_HARDLIGHT_EXT,
+  eSoftlightEXT = VK_BLEND_OP_SOFTLIGHT_EXT,
+  eDifferenceEXT = VK_BLEND_OP_DIFFERENCE_EXT,
+  eExclusionEXT = VK_BLEND_OP_EXCLUSION_EXT,
+  eInvertEXT = VK_BLEND_OP_INVERT_EXT,
+  eInvertRgbEXT = VK_BLEND_OP_INVERT_RGB_EXT,
+  eLineardodgeEXT = VK_BLEND_OP_LINEARDODGE_EXT,
+  eLinearburnEXT = VK_BLEND_OP_LINEARBURN_EXT,
+  eVividlightEXT = VK_BLEND_OP_VIVIDLIGHT_EXT,
+  eLinearlightEXT = VK_BLEND_OP_LINEARLIGHT_EXT,
+  ePinlightEXT = VK_BLEND_OP_PINLIGHT_EXT,
+  eHardmixEXT = VK_BLEND_OP_HARDMIX_EXT,
+  eHslHueEXT = VK_BLEND_OP_HSL_HUE_EXT,
+  eHslSaturationEXT = VK_BLEND_OP_HSL_SATURATION_EXT,
+  eHslColorEXT = VK_BLEND_OP_HSL_COLOR_EXT,
+  eHslLuminosityEXT = VK_BLEND_OP_HSL_LUMINOSITY_EXT,
+  ePlusEXT = VK_BLEND_OP_PLUS_EXT,
+  ePlusClampedEXT = VK_BLEND_OP_PLUS_CLAMPED_EXT,
+  ePlusClampedAlphaEXT = VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT,
+  ePlusDarkerEXT = VK_BLEND_OP_PLUS_DARKER_EXT,
+  eMinusEXT = VK_BLEND_OP_MINUS_EXT,
+  eMinusClampedEXT = VK_BLEND_OP_MINUS_CLAMPED_EXT,
+  eContrastEXT = VK_BLEND_OP_CONTRAST_EXT,
+  eInvertOvgEXT = VK_BLEND_OP_INVERT_OVG_EXT,
+  eRedEXT = VK_BLEND_OP_RED_EXT,
+  eGreenEXT = VK_BLEND_OP_GREEN_EXT,
+  eBlueEXT = VK_BLEND_OP_BLUE_EXT
+};
+
+VULKAN_HPP_INLINE std::string to_string(BlendOp value) {
+  switch (value) {
+  case BlendOp::eAdd:
+    return "Add";
+  case BlendOp::eSubtract:
+    return "Subtract";
+  case BlendOp::eReverseSubtract:
+    return "ReverseSubtract";
+  case BlendOp::eMin:
+    return "Min";
+  case BlendOp::eMax:
+    return "Max";
+  case BlendOp::eZeroEXT:
+    return "ZeroEXT";
+  case BlendOp::eSrcEXT:
+    return "SrcEXT";
+  case BlendOp::eDstEXT:
+    return "DstEXT";
+  case BlendOp::eSrcOverEXT:
+    return "SrcOverEXT";
+  case BlendOp::eDstOverEXT:
+    return "DstOverEXT";
+  case BlendOp::eSrcInEXT:
+    return "SrcInEXT";
+  case BlendOp::eDstInEXT:
+    return "DstInEXT";
+  case BlendOp::eSrcOutEXT:
+    return "SrcOutEXT";
+  case BlendOp::eDstOutEXT:
+    return "DstOutEXT";
+  case BlendOp::eSrcAtopEXT:
+    return "SrcAtopEXT";
+  case BlendOp::eDstAtopEXT:
+    return "DstAtopEXT";
+  case BlendOp::eXorEXT:
+    return "XorEXT";
+  case BlendOp::eMultiplyEXT:
+    return "MultiplyEXT";
+  case BlendOp::eScreenEXT:
+    return "ScreenEXT";
+  case BlendOp::eOverlayEXT:
+    return "OverlayEXT";
+  case BlendOp::eDarkenEXT:
+    return "DarkenEXT";
+  case BlendOp::eLightenEXT:
+    return "LightenEXT";
+  case BlendOp::eColordodgeEXT:
+    return "ColordodgeEXT";
+  case BlendOp::eColorburnEXT:
+    return "ColorburnEXT";
+  case BlendOp::eHardlightEXT:
+    return "HardlightEXT";
+  case BlendOp::eSoftlightEXT:
+    return "SoftlightEXT";
+  case BlendOp::eDifferenceEXT:
+    return "DifferenceEXT";
+  case BlendOp::eExclusionEXT:
+    return "ExclusionEXT";
+  case BlendOp::eInvertEXT:
+    return "InvertEXT";
+  case BlendOp::eInvertRgbEXT:
+    return "InvertRgbEXT";
+  case BlendOp::eLineardodgeEXT:
+    return "LineardodgeEXT";
+  case BlendOp::eLinearburnEXT:
+    return "LinearburnEXT";
+  case BlendOp::eVividlightEXT:
+    return "VividlightEXT";
+  case BlendOp::eLinearlightEXT:
+    return "LinearlightEXT";
+  case BlendOp::ePinlightEXT:
+    return "PinlightEXT";
+  case BlendOp::eHardmixEXT:
+    return "HardmixEXT";
+  case BlendOp::eHslHueEXT:
+    return "HslHueEXT";
+  case BlendOp::eHslSaturationEXT:
+    return "HslSaturationEXT";
+  case BlendOp::eHslColorEXT:
+    return "HslColorEXT";
+  case BlendOp::eHslLuminosityEXT:
+    return "HslLuminosityEXT";
+  case BlendOp::ePlusEXT:
+    return "PlusEXT";
+  case BlendOp::ePlusClampedEXT:
+    return "PlusClampedEXT";
+  case BlendOp::ePlusClampedAlphaEXT:
+    return "PlusClampedAlphaEXT";
+  case BlendOp::ePlusDarkerEXT:
+    return "PlusDarkerEXT";
+  case BlendOp::eMinusEXT:
+    return "MinusEXT";
+  case BlendOp::eMinusClampedEXT:
+    return "MinusClampedEXT";
+  case BlendOp::eContrastEXT:
+    return "ContrastEXT";
+  case BlendOp::eInvertOvgEXT:
+    return "InvertOvgEXT";
+  case BlendOp::eRedEXT:
+    return "RedEXT";
+  case BlendOp::eGreenEXT:
+    return "GreenEXT";
+  case BlendOp::eBlueEXT:
+    return "BlueEXT";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class ColorComponentFlagBits : VkColorComponentFlags {
+  eR = VK_COLOR_COMPONENT_R_BIT,
+  eG = VK_COLOR_COMPONENT_G_BIT,
+  eB = VK_COLOR_COMPONENT_B_BIT,
+  eA = VK_COLOR_COMPONENT_A_BIT
+};
+
+VULKAN_HPP_INLINE std::string to_string(ColorComponentFlagBits value) {
+  switch (value) {
+  case ColorComponentFlagBits::eR:
+    return "R";
+  case ColorComponentFlagBits::eG:
+    return "G";
+  case ColorComponentFlagBits::eB:
+    return "B";
+  case ColorComponentFlagBits::eA:
+    return "A";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class CompareOp {
+  eNever = VK_COMPARE_OP_NEVER,
+  eLess = VK_COMPARE_OP_LESS,
+  eEqual = VK_COMPARE_OP_EQUAL,
+  eLessOrEqual = VK_COMPARE_OP_LESS_OR_EQUAL,
+  eGreater = VK_COMPARE_OP_GREATER,
+  eNotEqual = VK_COMPARE_OP_NOT_EQUAL,
+  eGreaterOrEqual = VK_COMPARE_OP_GREATER_OR_EQUAL,
+  eAlways = VK_COMPARE_OP_ALWAYS
+};
+
+VULKAN_HPP_INLINE std::string to_string(CompareOp value) {
+  switch (value) {
+  case CompareOp::eNever:
+    return "Never";
+  case CompareOp::eLess:
+    return "Less";
+  case CompareOp::eEqual:
+    return "Equal";
+  case CompareOp::eLessOrEqual:
+    return "LessOrEqual";
+  case CompareOp::eGreater:
+    return "Greater";
+  case CompareOp::eNotEqual:
+    return "NotEqual";
+  case CompareOp::eGreaterOrEqual:
+    return "GreaterOrEqual";
+  case CompareOp::eAlways:
+    return "Always";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class CullModeFlagBits : VkCullModeFlags {
+  eNone = VK_CULL_MODE_NONE,
+  eFront = VK_CULL_MODE_FRONT_BIT,
+  eBack = VK_CULL_MODE_BACK_BIT,
+  eFrontAndBack = VK_CULL_MODE_FRONT_AND_BACK
+};
+
+VULKAN_HPP_INLINE std::string to_string(CullModeFlagBits value) {
+  switch (value) {
+  case CullModeFlagBits::eNone:
+    return "None";
+  case CullModeFlagBits::eFront:
+    return "Front";
+  case CullModeFlagBits::eBack:
+    return "Back";
+  case CullModeFlagBits::eFrontAndBack:
+    return "FrontAndBack";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class DynamicState {
+  eViewport = VK_DYNAMIC_STATE_VIEWPORT,
+  eScissor = VK_DYNAMIC_STATE_SCISSOR,
+  eLineWidth = VK_DYNAMIC_STATE_LINE_WIDTH,
+  eDepthBias = VK_DYNAMIC_STATE_DEPTH_BIAS,
+  eBlendConstants = VK_DYNAMIC_STATE_BLEND_CONSTANTS,
+  eDepthBounds = VK_DYNAMIC_STATE_DEPTH_BOUNDS,
+  eStencilCompareMask = VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK,
+  eStencilWriteMask = VK_DYNAMIC_STATE_STENCIL_WRITE_MASK,
+  eStencilReference = VK_DYNAMIC_STATE_STENCIL_REFERENCE,
+  eViewportWScalingNV = VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV,
+  eDiscardRectangleEXT = VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT,
+  eSampleLocationsEXT = VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT,
+  eRayTracingPipelineStackSizeKHR =
+      VK_DYNAMIC_STATE_RAY_TRACING_PIPELINE_STACK_SIZE_KHR,
+  eViewportShadingRatePaletteNV =
+      VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV,
+  eViewportCoarseSampleOrderNV =
+      VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV,
+  eExclusiveScissorNV = VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV,
+  eFragmentShadingRateKHR = VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR,
+  eLineStippleEXT = VK_DYNAMIC_STATE_LINE_STIPPLE_EXT,
+  eCullModeEXT = VK_DYNAMIC_STATE_CULL_MODE_EXT,
+  eFrontFaceEXT = VK_DYNAMIC_STATE_FRONT_FACE_EXT,
+  ePrimitiveTopologyEXT = VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT,
+  eViewportWithCountEXT = VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT,
+  eScissorWithCountEXT = VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT,
+  eVertexInputBindingStrideEXT =
+      VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT,
+  eDepthTestEnableEXT = VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE_EXT,
+  eDepthWriteEnableEXT = VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE_EXT,
+  eDepthCompareOpEXT = VK_DYNAMIC_STATE_DEPTH_COMPARE_OP_EXT,
+  eDepthBoundsTestEnableEXT = VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE_EXT,
+  eStencilTestEnableEXT = VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE_EXT,
+  eStencilOpEXT = VK_DYNAMIC_STATE_STENCIL_OP_EXT
+};
+
+VULKAN_HPP_INLINE std::string to_string(DynamicState value) {
+  switch (value) {
+  case DynamicState::eViewport:
+    return "Viewport";
+  case DynamicState::eScissor:
+    return "Scissor";
+  case DynamicState::eLineWidth:
+    return "LineWidth";
+  case DynamicState::eDepthBias:
+    return "DepthBias";
+  case DynamicState::eBlendConstants:
+    return "BlendConstants";
+  case DynamicState::eDepthBounds:
+    return "DepthBounds";
+  case DynamicState::eStencilCompareMask:
+    return "StencilCompareMask";
+  case DynamicState::eStencilWriteMask:
+    return "StencilWriteMask";
+  case DynamicState::eStencilReference:
+    return "StencilReference";
+  case DynamicState::eViewportWScalingNV:
+    return "ViewportWScalingNV";
+  case DynamicState::eDiscardRectangleEXT:
+    return "DiscardRectangleEXT";
+  case DynamicState::eSampleLocationsEXT:
+    return "SampleLocationsEXT";
+  case DynamicState::eRayTracingPipelineStackSizeKHR:
+    return "RayTracingPipelineStackSizeKHR";
+  case DynamicState::eViewportShadingRatePaletteNV:
+    return "ViewportShadingRatePaletteNV";
+  case DynamicState::eViewportCoarseSampleOrderNV:
+    return "ViewportCoarseSampleOrderNV";
+  case DynamicState::eExclusiveScissorNV:
+    return "ExclusiveScissorNV";
+  case DynamicState::eFragmentShadingRateKHR:
+    return "FragmentShadingRateKHR";
+  case DynamicState::eLineStippleEXT:
+    return "LineStippleEXT";
+  case DynamicState::eCullModeEXT:
+    return "CullModeEXT";
+  case DynamicState::eFrontFaceEXT:
+    return "FrontFaceEXT";
+  case DynamicState::ePrimitiveTopologyEXT:
+    return "PrimitiveTopologyEXT";
+  case DynamicState::eViewportWithCountEXT:
+    return "ViewportWithCountEXT";
+  case DynamicState::eScissorWithCountEXT:
+    return "ScissorWithCountEXT";
+  case DynamicState::eVertexInputBindingStrideEXT:
+    return "VertexInputBindingStrideEXT";
+  case DynamicState::eDepthTestEnableEXT:
+    return "DepthTestEnableEXT";
+  case DynamicState::eDepthWriteEnableEXT:
+    return "DepthWriteEnableEXT";
+  case DynamicState::eDepthCompareOpEXT:
+    return "DepthCompareOpEXT";
+  case DynamicState::eDepthBoundsTestEnableEXT:
+    return "DepthBoundsTestEnableEXT";
+  case DynamicState::eStencilTestEnableEXT:
+    return "StencilTestEnableEXT";
+  case DynamicState::eStencilOpEXT:
+    return "StencilOpEXT";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class FrontFace {
+  eCounterClockwise = VK_FRONT_FACE_COUNTER_CLOCKWISE,
+  eClockwise = VK_FRONT_FACE_CLOCKWISE
+};
+
+VULKAN_HPP_INLINE std::string to_string(FrontFace value) {
+  switch (value) {
+  case FrontFace::eCounterClockwise:
+    return "CounterClockwise";
+  case FrontFace::eClockwise:
+    return "Clockwise";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class LogicOp {
+  eClear = VK_LOGIC_OP_CLEAR,
+  eAnd = VK_LOGIC_OP_AND,
+  eAndReverse = VK_LOGIC_OP_AND_REVERSE,
+  eCopy = VK_LOGIC_OP_COPY,
+  eAndInverted = VK_LOGIC_OP_AND_INVERTED,
+  eNoOp = VK_LOGIC_OP_NO_OP,
+  eXor = VK_LOGIC_OP_XOR,
+  eOr = VK_LOGIC_OP_OR,
+  eNor = VK_LOGIC_OP_NOR,
+  eEquivalent = VK_LOGIC_OP_EQUIVALENT,
+  eInvert = VK_LOGIC_OP_INVERT,
+  eOrReverse = VK_LOGIC_OP_OR_REVERSE,
+  eCopyInverted = VK_LOGIC_OP_COPY_INVERTED,
+  eOrInverted = VK_LOGIC_OP_OR_INVERTED,
+  eNand = VK_LOGIC_OP_NAND,
+  eSet = VK_LOGIC_OP_SET
+};
+
+VULKAN_HPP_INLINE std::string to_string(LogicOp value) {
+  switch (value) {
+  case LogicOp::eClear:
+    return "Clear";
+  case LogicOp::eAnd:
+    return "And";
+  case LogicOp::eAndReverse:
+    return "AndReverse";
+  case LogicOp::eCopy:
+    return "Copy";
+  case LogicOp::eAndInverted:
+    return "AndInverted";
+  case LogicOp::eNoOp:
+    return "NoOp";
+  case LogicOp::eXor:
+    return "Xor";
+  case LogicOp::eOr:
+    return "Or";
+  case LogicOp::eNor:
+    return "Nor";
+  case LogicOp::eEquivalent:
+    return "Equivalent";
+  case LogicOp::eInvert:
+    return "Invert";
+  case LogicOp::eOrReverse:
+    return "OrReverse";
+  case LogicOp::eCopyInverted:
+    return "CopyInverted";
+  case LogicOp::eOrInverted:
+    return "OrInverted";
+  case LogicOp::eNand:
+    return "Nand";
+  case LogicOp::eSet:
+    return "Set";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class PipelineCreateFlagBits : VkPipelineCreateFlags {
+  eDisableOptimization = VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT,
+  eAllowDerivatives = VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT,
+  eDerivative = VK_PIPELINE_CREATE_DERIVATIVE_BIT,
+  eViewIndexFromDeviceIndex =
+      VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT,
+  eDispatchBase = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT,
+  eRayTracingNoNullAnyHitShadersKHR =
+      VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR,
+  eRayTracingNoNullClosestHitShadersKHR =
+      VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR,
+  eRayTracingNoNullMissShadersKHR =
+      VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR,
+  eRayTracingNoNullIntersectionShadersKHR =
+      VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR,
+  eRayTracingSkipTrianglesKHR =
+      VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR,
+  eRayTracingSkipAabbsKHR = VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR,
+  eRayTracingShaderGroupHandleCaptureReplayKHR =
+      VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR,
+  eDeferCompileNV = VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV,
+  eCaptureStatisticsKHR = VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR,
+  eCaptureInternalRepresentationsKHR =
+      VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR,
+  eIndirectBindableNV = VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV,
+  eLibraryKHR = VK_PIPELINE_CREATE_LIBRARY_BIT_KHR,
+  eFailOnPipelineCompileRequiredEXT =
+      VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_EXT,
+  eEarlyReturnOnFailureEXT = VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT_EXT,
+  eDispatchBaseKHR = VK_PIPELINE_CREATE_DISPATCH_BASE_KHR,
+  eViewIndexFromDeviceIndexKHR =
+      VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR
+};
+
+VULKAN_HPP_INLINE std::string to_string(PipelineCreateFlagBits value) {
+  switch (value) {
+  case PipelineCreateFlagBits::eDisableOptimization:
+    return "DisableOptimization";
+  case PipelineCreateFlagBits::eAllowDerivatives:
+    return "AllowDerivatives";
+  case PipelineCreateFlagBits::eDerivative:
+    return "Derivative";
+  case PipelineCreateFlagBits::eViewIndexFromDeviceIndex:
+    return "ViewIndexFromDeviceIndex";
+  case PipelineCreateFlagBits::eDispatchBase:
+    return "DispatchBase";
+  case PipelineCreateFlagBits::eRayTracingNoNullAnyHitShadersKHR:
+    return "RayTracingNoNullAnyHitShadersKHR";
+  case PipelineCreateFlagBits::eRayTracingNoNullClosestHitShadersKHR:
+    return "RayTracingNoNullClosestHitShadersKHR";
+  case PipelineCreateFlagBits::eRayTracingNoNullMissShadersKHR:
+    return "RayTracingNoNullMissShadersKHR";
+  case PipelineCreateFlagBits::eRayTracingNoNullIntersectionShadersKHR:
+    return "RayTracingNoNullIntersectionShadersKHR";
+  case PipelineCreateFlagBits::eRayTracingSkipTrianglesKHR:
+    return "RayTracingSkipTrianglesKHR";
+  case PipelineCreateFlagBits::eRayTracingSkipAabbsKHR:
+    return "RayTracingSkipAabbsKHR";
+  case PipelineCreateFlagBits::eRayTracingShaderGroupHandleCaptureReplayKHR:
+    return "RayTracingShaderGroupHandleCaptureReplayKHR";
+  case PipelineCreateFlagBits::eDeferCompileNV:
+    return "DeferCompileNV";
+  case PipelineCreateFlagBits::eCaptureStatisticsKHR:
+    return "CaptureStatisticsKHR";
+  case PipelineCreateFlagBits::eCaptureInternalRepresentationsKHR:
+    return "CaptureInternalRepresentationsKHR";
+  case PipelineCreateFlagBits::eIndirectBindableNV:
+    return "IndirectBindableNV";
+  case PipelineCreateFlagBits::eLibraryKHR:
+    return "LibraryKHR";
+  case PipelineCreateFlagBits::eFailOnPipelineCompileRequiredEXT:
+    return "FailOnPipelineCompileRequiredEXT";
+  case PipelineCreateFlagBits::eEarlyReturnOnFailureEXT:
+    return "EarlyReturnOnFailureEXT";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class
+    PipelineShaderStageCreateFlagBits : VkPipelineShaderStageCreateFlags {
+      eAllowVaryingSubgroupSizeEXT =
+          VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT,
+      eRequireFullSubgroupsEXT =
+          VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT
+    };
+
+VULKAN_HPP_INLINE std::string
+to_string(PipelineShaderStageCreateFlagBits value) {
+  switch (value) {
+  case PipelineShaderStageCreateFlagBits::eAllowVaryingSubgroupSizeEXT:
+    return "AllowVaryingSubgroupSizeEXT";
+  case PipelineShaderStageCreateFlagBits::eRequireFullSubgroupsEXT:
+    return "RequireFullSubgroupsEXT";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class PolygonMode {
+  eFill = VK_POLYGON_MODE_FILL,
+  eLine = VK_POLYGON_MODE_LINE,
+  ePoint = VK_POLYGON_MODE_POINT,
+  eFillRectangleNV = VK_POLYGON_MODE_FILL_RECTANGLE_NV
+};
+
+VULKAN_HPP_INLINE std::string to_string(PolygonMode value) {
+  switch (value) {
+  case PolygonMode::eFill:
+    return "Fill";
+  case PolygonMode::eLine:
+    return "Line";
+  case PolygonMode::ePoint:
+    return "Point";
+  case PolygonMode::eFillRectangleNV:
+    return "FillRectangleNV";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class PrimitiveTopology {
+  ePointList = VK_PRIMITIVE_TOPOLOGY_POINT_LIST,
+  eLineList = VK_PRIMITIVE_TOPOLOGY_LINE_LIST,
+  eLineStrip = VK_PRIMITIVE_TOPOLOGY_LINE_STRIP,
+  eTriangleList = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
+  eTriangleStrip = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP,
+  eTriangleFan = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN,
+  eLineListWithAdjacency = VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY,
+  eLineStripWithAdjacency = VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY,
+  eTriangleListWithAdjacency =
+      VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY,
+  eTriangleStripWithAdjacency =
+      VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY,
+  ePatchList = VK_PRIMITIVE_TOPOLOGY_PATCH_LIST
+};
+
+VULKAN_HPP_INLINE std::string to_string(PrimitiveTopology value) {
+  switch (value) {
+  case PrimitiveTopology::ePointList:
+    return "PointList";
+  case PrimitiveTopology::eLineList:
+    return "LineList";
+  case PrimitiveTopology::eLineStrip:
+    return "LineStrip";
+  case PrimitiveTopology::eTriangleList:
+    return "TriangleList";
+  case PrimitiveTopology::eTriangleStrip:
+    return "TriangleStrip";
+  case PrimitiveTopology::eTriangleFan:
+    return "TriangleFan";
+  case PrimitiveTopology::eLineListWithAdjacency:
+    return "LineListWithAdjacency";
+  case PrimitiveTopology::eLineStripWithAdjacency:
+    return "LineStripWithAdjacency";
+  case PrimitiveTopology::eTriangleListWithAdjacency:
+    return "TriangleListWithAdjacency";
+  case PrimitiveTopology::eTriangleStripWithAdjacency:
+    return "TriangleStripWithAdjacency";
+  case PrimitiveTopology::ePatchList:
+    return "PatchList";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class ShaderStageFlagBits : VkShaderStageFlags {
+  eVertex = VK_SHADER_STAGE_VERTEX_BIT,
+  eTessellationControl = VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT,
+  eTessellationEvaluation = VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT,
+  eGeometry = VK_SHADER_STAGE_GEOMETRY_BIT,
+  eFragment = VK_SHADER_STAGE_FRAGMENT_BIT,
+  eCompute = VK_SHADER_STAGE_COMPUTE_BIT,
+  eAllGraphics = VK_SHADER_STAGE_ALL_GRAPHICS,
+  eAll = VK_SHADER_STAGE_ALL,
+  eRaygenKHR = VK_SHADER_STAGE_RAYGEN_BIT_KHR,
+  eAnyHitKHR = VK_SHADER_STAGE_ANY_HIT_BIT_KHR,
+  eClosestHitKHR = VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR,
+  eMissKHR = VK_SHADER_STAGE_MISS_BIT_KHR,
+  eIntersectionKHR = VK_SHADER_STAGE_INTERSECTION_BIT_KHR,
+  eCallableKHR = VK_SHADER_STAGE_CALLABLE_BIT_KHR,
+  eTaskNV = VK_SHADER_STAGE_TASK_BIT_NV,
+  eMeshNV = VK_SHADER_STAGE_MESH_BIT_NV,
+  eAnyHitNV = VK_SHADER_STAGE_ANY_HIT_BIT_NV,
+  eCallableNV = VK_SHADER_STAGE_CALLABLE_BIT_NV,
+  eClosestHitNV = VK_SHADER_STAGE_CLOSEST_HIT_BIT_NV,
+  eIntersectionNV = VK_SHADER_STAGE_INTERSECTION_BIT_NV,
+  eMissNV = VK_SHADER_STAGE_MISS_BIT_NV,
+  eRaygenNV = VK_SHADER_STAGE_RAYGEN_BIT_NV
+};
+
+VULKAN_HPP_INLINE std::string to_string(ShaderStageFlagBits value) {
+  switch (value) {
+  case ShaderStageFlagBits::eVertex:
+    return "Vertex";
+  case ShaderStageFlagBits::eTessellationControl:
+    return "TessellationControl";
+  case ShaderStageFlagBits::eTessellationEvaluation:
+    return "TessellationEvaluation";
+  case ShaderStageFlagBits::eGeometry:
+    return "Geometry";
+  case ShaderStageFlagBits::eFragment:
+    return "Fragment";
+  case ShaderStageFlagBits::eCompute:
+    return "Compute";
+  case ShaderStageFlagBits::eAllGraphics:
+    return "AllGraphics";
+  case ShaderStageFlagBits::eAll:
+    return "All";
+  case ShaderStageFlagBits::eRaygenKHR:
+    return "RaygenKHR";
+  case ShaderStageFlagBits::eAnyHitKHR:
+    return "AnyHitKHR";
+  case ShaderStageFlagBits::eClosestHitKHR:
+    return "ClosestHitKHR";
+  case ShaderStageFlagBits::eMissKHR:
+    return "MissKHR";
+  case ShaderStageFlagBits::eIntersectionKHR:
+    return "IntersectionKHR";
+  case ShaderStageFlagBits::eCallableKHR:
+    return "CallableKHR";
+  case ShaderStageFlagBits::eTaskNV:
+    return "TaskNV";
+  case ShaderStageFlagBits::eMeshNV:
+    return "MeshNV";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class StencilOp {
+  eKeep = VK_STENCIL_OP_KEEP,
+  eZero = VK_STENCIL_OP_ZERO,
+  eReplace = VK_STENCIL_OP_REPLACE,
+  eIncrementAndClamp = VK_STENCIL_OP_INCREMENT_AND_CLAMP,
+  eDecrementAndClamp = VK_STENCIL_OP_DECREMENT_AND_CLAMP,
+  eInvert = VK_STENCIL_OP_INVERT,
+  eIncrementAndWrap = VK_STENCIL_OP_INCREMENT_AND_WRAP,
+  eDecrementAndWrap = VK_STENCIL_OP_DECREMENT_AND_WRAP
+};
+
+VULKAN_HPP_INLINE std::string to_string(StencilOp value) {
+  switch (value) {
+  case StencilOp::eKeep:
+    return "Keep";
+  case StencilOp::eZero:
+    return "Zero";
+  case StencilOp::eReplace:
+    return "Replace";
+  case StencilOp::eIncrementAndClamp:
+    return "IncrementAndClamp";
+  case StencilOp::eDecrementAndClamp:
+    return "DecrementAndClamp";
+  case StencilOp::eInvert:
+    return "Invert";
+  case StencilOp::eIncrementAndWrap:
+    return "IncrementAndWrap";
+  case StencilOp::eDecrementAndWrap:
+    return "DecrementAndWrap";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class VertexInputRate {
+  eVertex = VK_VERTEX_INPUT_RATE_VERTEX,
+  eInstance = VK_VERTEX_INPUT_RATE_INSTANCE
+};
+
+VULKAN_HPP_INLINE std::string to_string(VertexInputRate value) {
+  switch (value) {
+  case VertexInputRate::eVertex:
+    return "Vertex";
+  case VertexInputRate::eInstance:
+    return "Instance";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class BorderColor {
+  eFloatTransparentBlack = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,
+  eIntTransparentBlack = VK_BORDER_COLOR_INT_TRANSPARENT_BLACK,
+  eFloatOpaqueBlack = VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK,
+  eIntOpaqueBlack = VK_BORDER_COLOR_INT_OPAQUE_BLACK,
+  eFloatOpaqueWhite = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE,
+  eIntOpaqueWhite = VK_BORDER_COLOR_INT_OPAQUE_WHITE,
+  eFloatCustomEXT = VK_BORDER_COLOR_FLOAT_CUSTOM_EXT,
+  eIntCustomEXT = VK_BORDER_COLOR_INT_CUSTOM_EXT
+};
+
+VULKAN_HPP_INLINE std::string to_string(BorderColor value) {
+  switch (value) {
+  case BorderColor::eFloatTransparentBlack:
+    return "FloatTransparentBlack";
+  case BorderColor::eIntTransparentBlack:
+    return "IntTransparentBlack";
+  case BorderColor::eFloatOpaqueBlack:
+    return "FloatOpaqueBlack";
+  case BorderColor::eIntOpaqueBlack:
+    return "IntOpaqueBlack";
+  case BorderColor::eFloatOpaqueWhite:
+    return "FloatOpaqueWhite";
+  case BorderColor::eIntOpaqueWhite:
+    return "IntOpaqueWhite";
+  case BorderColor::eFloatCustomEXT:
+    return "FloatCustomEXT";
+  case BorderColor::eIntCustomEXT:
+    return "IntCustomEXT";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class Filter {
+  eNearest = VK_FILTER_NEAREST,
+  eLinear = VK_FILTER_LINEAR,
+  eCubicIMG = VK_FILTER_CUBIC_IMG,
+  eCubicEXT = VK_FILTER_CUBIC_EXT
+};
+
+VULKAN_HPP_INLINE std::string to_string(Filter value) {
+  switch (value) {
+  case Filter::eNearest:
+    return "Nearest";
+  case Filter::eLinear:
+    return "Linear";
+  case Filter::eCubicIMG:
+    return "CubicIMG";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class SamplerAddressMode {
+  eRepeat = VK_SAMPLER_ADDRESS_MODE_REPEAT,
+  eMirroredRepeat = VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT,
+  eClampToEdge = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
+  eClampToBorder = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER,
+  eMirrorClampToEdge = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE,
+  eMirrorClampToEdgeKHR = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE_KHR
+};
+
+VULKAN_HPP_INLINE std::string to_string(SamplerAddressMode value) {
+  switch (value) {
+  case SamplerAddressMode::eRepeat:
+    return "Repeat";
+  case SamplerAddressMode::eMirroredRepeat:
+    return "MirroredRepeat";
+  case SamplerAddressMode::eClampToEdge:
+    return "ClampToEdge";
+  case SamplerAddressMode::eClampToBorder:
+    return "ClampToBorder";
+  case SamplerAddressMode::eMirrorClampToEdge:
+    return "MirrorClampToEdge";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class SamplerCreateFlagBits : VkSamplerCreateFlags {
+  eSubsampledEXT = VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT,
+  eSubsampledCoarseReconstructionEXT =
+      VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT
+};
+
+VULKAN_HPP_INLINE std::string to_string(SamplerCreateFlagBits value) {
+  switch (value) {
+  case SamplerCreateFlagBits::eSubsampledEXT:
+    return "SubsampledEXT";
+  case SamplerCreateFlagBits::eSubsampledCoarseReconstructionEXT:
+    return "SubsampledCoarseReconstructionEXT";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class SamplerMipmapMode {
+  eNearest = VK_SAMPLER_MIPMAP_MODE_NEAREST,
+  eLinear = VK_SAMPLER_MIPMAP_MODE_LINEAR
+};
+
+VULKAN_HPP_INLINE std::string to_string(SamplerMipmapMode value) {
+  switch (value) {
+  case SamplerMipmapMode::eNearest:
+    return "Nearest";
+  case SamplerMipmapMode::eLinear:
+    return "Linear";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class DescriptorPoolCreateFlagBits : VkDescriptorPoolCreateFlags {
+  eFreeDescriptorSet = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT,
+  eUpdateAfterBind = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT,
+  eHostOnlyVALVE = VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE,
+  eUpdateAfterBindEXT = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT
+};
+
+VULKAN_HPP_INLINE std::string to_string(DescriptorPoolCreateFlagBits value) {
+  switch (value) {
+  case DescriptorPoolCreateFlagBits::eFreeDescriptorSet:
+    return "FreeDescriptorSet";
+  case DescriptorPoolCreateFlagBits::eUpdateAfterBind:
+    return "UpdateAfterBind";
+  case DescriptorPoolCreateFlagBits::eHostOnlyVALVE:
+    return "HostOnlyVALVE";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class
+    DescriptorSetLayoutCreateFlagBits : VkDescriptorSetLayoutCreateFlags {
+      eUpdateAfterBindPool =
+          VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT,
+      ePushDescriptorKHR =
+          VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR,
+      eHostOnlyPoolVALVE =
+          VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE,
+      eUpdateAfterBindPoolEXT =
+          VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT
+    };
+
+VULKAN_HPP_INLINE std::string
+to_string(DescriptorSetLayoutCreateFlagBits value) {
+  switch (value) {
+  case DescriptorSetLayoutCreateFlagBits::eUpdateAfterBindPool:
+    return "UpdateAfterBindPool";
+  case DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR:
+    return "PushDescriptorKHR";
+  case DescriptorSetLayoutCreateFlagBits::eHostOnlyPoolVALVE:
+    return "HostOnlyPoolVALVE";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class DescriptorType {
+  eSampler = VK_DESCRIPTOR_TYPE_SAMPLER,
+  eCombinedImageSampler = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
+  eSampledImage = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
+  eStorageImage = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
+  eUniformTexelBuffer = VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER,
+  eStorageTexelBuffer = VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER,
+  eUniformBuffer = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
+  eStorageBuffer = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
+  eUniformBufferDynamic = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC,
+  eStorageBufferDynamic = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC,
+  eInputAttachment = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
+  eInlineUniformBlockEXT = VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT,
+  eAccelerationStructureKHR = VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR,
+  eAccelerationStructureNV = VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV,
+  eMutableVALVE = VK_DESCRIPTOR_TYPE_MUTABLE_VALVE
+};
+
+VULKAN_HPP_INLINE std::string to_string(DescriptorType value) {
+  switch (value) {
+  case DescriptorType::eSampler:
+    return "Sampler";
+  case DescriptorType::eCombinedImageSampler:
+    return "CombinedImageSampler";
+  case DescriptorType::eSampledImage:
+    return "SampledImage";
+  case DescriptorType::eStorageImage:
+    return "StorageImage";
+  case DescriptorType::eUniformTexelBuffer:
+    return "UniformTexelBuffer";
+  case DescriptorType::eStorageTexelBuffer:
+    return "StorageTexelBuffer";
+  case DescriptorType::eUniformBuffer:
+    return "UniformBuffer";
+  case DescriptorType::eStorageBuffer:
+    return "StorageBuffer";
+  case DescriptorType::eUniformBufferDynamic:
+    return "UniformBufferDynamic";
+  case DescriptorType::eStorageBufferDynamic:
+    return "StorageBufferDynamic";
+  case DescriptorType::eInputAttachment:
+    return "InputAttachment";
+  case DescriptorType::eInlineUniformBlockEXT:
+    return "InlineUniformBlockEXT";
+  case DescriptorType::eAccelerationStructureKHR:
+    return "AccelerationStructureKHR";
+  case DescriptorType::eAccelerationStructureNV:
+    return "AccelerationStructureNV";
+  case DescriptorType::eMutableVALVE:
+    return "MutableVALVE";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class AccessFlagBits : VkAccessFlags {
+  eIndirectCommandRead = VK_ACCESS_INDIRECT_COMMAND_READ_BIT,
+  eIndexRead = VK_ACCESS_INDEX_READ_BIT,
+  eVertexAttributeRead = VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT,
+  eUniformRead = VK_ACCESS_UNIFORM_READ_BIT,
+  eInputAttachmentRead = VK_ACCESS_INPUT_ATTACHMENT_READ_BIT,
+  eShaderRead = VK_ACCESS_SHADER_READ_BIT,
+  eShaderWrite = VK_ACCESS_SHADER_WRITE_BIT,
+  eColorAttachmentRead = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT,
+  eColorAttachmentWrite = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+  eDepthStencilAttachmentRead = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT,
+  eDepthStencilAttachmentWrite = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
+  eTransferRead = VK_ACCESS_TRANSFER_READ_BIT,
+  eTransferWrite = VK_ACCESS_TRANSFER_WRITE_BIT,
+  eHostRead = VK_ACCESS_HOST_READ_BIT,
+  eHostWrite = VK_ACCESS_HOST_WRITE_BIT,
+  eMemoryRead = VK_ACCESS_MEMORY_READ_BIT,
+  eMemoryWrite = VK_ACCESS_MEMORY_WRITE_BIT,
+  eTransformFeedbackWriteEXT = VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT,
+  eTransformFeedbackCounterReadEXT =
+      VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT,
+  eTransformFeedbackCounterWriteEXT =
+      VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT,
+  eConditionalRenderingReadEXT = VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT,
+  eColorAttachmentReadNoncoherentEXT =
+      VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT,
+  eAccelerationStructureReadKHR = VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR,
+  eAccelerationStructureWriteKHR =
+      VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR,
+  eShadingRateImageReadNV = VK_ACCESS_SHADING_RATE_IMAGE_READ_BIT_NV,
+  eFragmentDensityMapReadEXT = VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT,
+  eCommandPreprocessReadNV = VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_NV,
+  eCommandPreprocessWriteNV = VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_NV,
+  eNoneKHR = VK_ACCESS_NONE_KHR,
+  eAccelerationStructureReadNV = VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NV,
+  eAccelerationStructureWriteNV = VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NV,
+  eFragmentShadingRateAttachmentReadKHR =
+      VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR
+};
+
+VULKAN_HPP_INLINE std::string to_string(AccessFlagBits value) {
+  switch (value) {
+  case AccessFlagBits::eIndirectCommandRead:
+    return "IndirectCommandRead";
+  case AccessFlagBits::eIndexRead:
+    return "IndexRead";
+  case AccessFlagBits::eVertexAttributeRead:
+    return "VertexAttributeRead";
+  case AccessFlagBits::eUniformRead:
+    return "UniformRead";
+  case AccessFlagBits::eInputAttachmentRead:
+    return "InputAttachmentRead";
+  case AccessFlagBits::eShaderRead:
+    return "ShaderRead";
+  case AccessFlagBits::eShaderWrite:
+    return "ShaderWrite";
+  case AccessFlagBits::eColorAttachmentRead:
+    return "ColorAttachmentRead";
+  case AccessFlagBits::eColorAttachmentWrite:
+    return "ColorAttachmentWrite";
+  case AccessFlagBits::eDepthStencilAttachmentRead:
+    return "DepthStencilAttachmentRead";
+  case AccessFlagBits::eDepthStencilAttachmentWrite:
+    return "DepthStencilAttachmentWrite";
+  case AccessFlagBits::eTransferRead:
+    return "TransferRead";
+  case AccessFlagBits::eTransferWrite:
+    return "TransferWrite";
+  case AccessFlagBits::eHostRead:
+    return "HostRead";
+  case AccessFlagBits::eHostWrite:
+    return "HostWrite";
+  case AccessFlagBits::eMemoryRead:
+    return "MemoryRead";
+  case AccessFlagBits::eMemoryWrite:
+    return "MemoryWrite";
+  case AccessFlagBits::eTransformFeedbackWriteEXT:
+    return "TransformFeedbackWriteEXT";
+  case AccessFlagBits::eTransformFeedbackCounterReadEXT:
+    return "TransformFeedbackCounterReadEXT";
+  case AccessFlagBits::eTransformFeedbackCounterWriteEXT:
+    return "TransformFeedbackCounterWriteEXT";
+  case AccessFlagBits::eConditionalRenderingReadEXT:
+    return "ConditionalRenderingReadEXT";
+  case AccessFlagBits::eColorAttachmentReadNoncoherentEXT:
+    return "ColorAttachmentReadNoncoherentEXT";
+  case AccessFlagBits::eAccelerationStructureReadKHR:
+    return "AccelerationStructureReadKHR";
+  case AccessFlagBits::eAccelerationStructureWriteKHR:
+    return "AccelerationStructureWriteKHR";
+  case AccessFlagBits::eShadingRateImageReadNV:
+    return "ShadingRateImageReadNV";
+  case AccessFlagBits::eFragmentDensityMapReadEXT:
+    return "FragmentDensityMapReadEXT";
+  case AccessFlagBits::eCommandPreprocessReadNV:
+    return "CommandPreprocessReadNV";
+  case AccessFlagBits::eCommandPreprocessWriteNV:
+    return "CommandPreprocessWriteNV";
+  case AccessFlagBits::eNoneKHR:
+    return "NoneKHR";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class AttachmentDescriptionFlagBits : VkAttachmentDescriptionFlags {
+  eMayAlias = VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT
+};
+
+VULKAN_HPP_INLINE std::string to_string(AttachmentDescriptionFlagBits value) {
+  switch (value) {
+  case AttachmentDescriptionFlagBits::eMayAlias:
+    return "MayAlias";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class AttachmentLoadOp {
+  eLoad = VK_ATTACHMENT_LOAD_OP_LOAD,
+  eClear = VK_ATTACHMENT_LOAD_OP_CLEAR,
+  eDontCare = VK_ATTACHMENT_LOAD_OP_DONT_CARE
+};
+
+VULKAN_HPP_INLINE std::string to_string(AttachmentLoadOp value) {
+  switch (value) {
+  case AttachmentLoadOp::eLoad:
+    return "Load";
+  case AttachmentLoadOp::eClear:
+    return "Clear";
+  case AttachmentLoadOp::eDontCare:
+    return "DontCare";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class AttachmentStoreOp {
+  eStore = VK_ATTACHMENT_STORE_OP_STORE,
+  eDontCare = VK_ATTACHMENT_STORE_OP_DONT_CARE,
+  eNoneQCOM = VK_ATTACHMENT_STORE_OP_NONE_QCOM
+};
+
+VULKAN_HPP_INLINE std::string to_string(AttachmentStoreOp value) {
+  switch (value) {
+  case AttachmentStoreOp::eStore:
+    return "Store";
+  case AttachmentStoreOp::eDontCare:
+    return "DontCare";
+  case AttachmentStoreOp::eNoneQCOM:
+    return "NoneQCOM";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class DependencyFlagBits : VkDependencyFlags {
+  eByRegion = VK_DEPENDENCY_BY_REGION_BIT,
+  eDeviceGroup = VK_DEPENDENCY_DEVICE_GROUP_BIT,
+  eViewLocal = VK_DEPENDENCY_VIEW_LOCAL_BIT,
+  eDeviceGroupKHR = VK_DEPENDENCY_DEVICE_GROUP_BIT_KHR,
+  eViewLocalKHR = VK_DEPENDENCY_VIEW_LOCAL_BIT_KHR
+};
+
+VULKAN_HPP_INLINE std::string to_string(DependencyFlagBits value) {
+  switch (value) {
+  case DependencyFlagBits::eByRegion:
+    return "ByRegion";
+  case DependencyFlagBits::eDeviceGroup:
+    return "DeviceGroup";
+  case DependencyFlagBits::eViewLocal:
+    return "ViewLocal";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class FramebufferCreateFlagBits : VkFramebufferCreateFlags {
+  eImageless = VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT,
+  eImagelessKHR = VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR
+};
+
+VULKAN_HPP_INLINE std::string to_string(FramebufferCreateFlagBits value) {
+  switch (value) {
+  case FramebufferCreateFlagBits::eImageless:
+    return "Imageless";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class PipelineBindPoint {
+  eGraphics = VK_PIPELINE_BIND_POINT_GRAPHICS,
+  eCompute = VK_PIPELINE_BIND_POINT_COMPUTE,
+  eRayTracingKHR = VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR,
+  eRayTracingNV = VK_PIPELINE_BIND_POINT_RAY_TRACING_NV
+};
+
+VULKAN_HPP_INLINE std::string to_string(PipelineBindPoint value) {
+  switch (value) {
+  case PipelineBindPoint::eGraphics:
+    return "Graphics";
+  case PipelineBindPoint::eCompute:
+    return "Compute";
+  case PipelineBindPoint::eRayTracingKHR:
+    return "RayTracingKHR";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class RenderPassCreateFlagBits : VkRenderPassCreateFlags {
+  eTransformQCOM = VK_RENDER_PASS_CREATE_TRANSFORM_BIT_QCOM
+};
+
+VULKAN_HPP_INLINE std::string to_string(RenderPassCreateFlagBits value) {
+  switch (value) {
+  case RenderPassCreateFlagBits::eTransformQCOM:
+    return "TransformQCOM";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class SubpassDescriptionFlagBits : VkSubpassDescriptionFlags {
+  ePerViewAttributesNVX = VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX,
+  ePerViewPositionXOnlyNVX =
+      VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX,
+  eFragmentRegionQCOM = VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM,
+  eShaderResolveQCOM = VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM
+};
+
+VULKAN_HPP_INLINE std::string to_string(SubpassDescriptionFlagBits value) {
+  switch (value) {
+  case SubpassDescriptionFlagBits::ePerViewAttributesNVX:
+    return "PerViewAttributesNVX";
+  case SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX:
+    return "PerViewPositionXOnlyNVX";
+  case SubpassDescriptionFlagBits::eFragmentRegionQCOM:
+    return "FragmentRegionQCOM";
+  case SubpassDescriptionFlagBits::eShaderResolveQCOM:
+    return "ShaderResolveQCOM";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class CommandPoolCreateFlagBits : VkCommandPoolCreateFlags {
+  eTransient = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT,
+  eResetCommandBuffer = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,
+  eProtected = VK_COMMAND_POOL_CREATE_PROTECTED_BIT
+};
+
+VULKAN_HPP_INLINE std::string to_string(CommandPoolCreateFlagBits value) {
+  switch (value) {
+  case CommandPoolCreateFlagBits::eTransient:
+    return "Transient";
+  case CommandPoolCreateFlagBits::eResetCommandBuffer:
+    return "ResetCommandBuffer";
+  case CommandPoolCreateFlagBits::eProtected:
+    return "Protected";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class CommandPoolResetFlagBits : VkCommandPoolResetFlags {
+  eReleaseResources = VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT
+};
+
+VULKAN_HPP_INLINE std::string to_string(CommandPoolResetFlagBits value) {
+  switch (value) {
+  case CommandPoolResetFlagBits::eReleaseResources:
+    return "ReleaseResources";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class CommandBufferLevel {
+  ePrimary = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
+  eSecondary = VK_COMMAND_BUFFER_LEVEL_SECONDARY
+};
+
+VULKAN_HPP_INLINE std::string to_string(CommandBufferLevel value) {
+  switch (value) {
+  case CommandBufferLevel::ePrimary:
+    return "Primary";
+  case CommandBufferLevel::eSecondary:
+    return "Secondary";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class CommandBufferResetFlagBits : VkCommandBufferResetFlags {
+  eReleaseResources = VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT
+};
+
+VULKAN_HPP_INLINE std::string to_string(CommandBufferResetFlagBits value) {
+  switch (value) {
+  case CommandBufferResetFlagBits::eReleaseResources:
+    return "ReleaseResources";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class CommandBufferUsageFlagBits : VkCommandBufferUsageFlags {
+  eOneTimeSubmit = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
+  eRenderPassContinue = VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT,
+  eSimultaneousUse = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT
+};
+
+VULKAN_HPP_INLINE std::string to_string(CommandBufferUsageFlagBits value) {
+  switch (value) {
+  case CommandBufferUsageFlagBits::eOneTimeSubmit:
+    return "OneTimeSubmit";
+  case CommandBufferUsageFlagBits::eRenderPassContinue:
+    return "RenderPassContinue";
+  case CommandBufferUsageFlagBits::eSimultaneousUse:
+    return "SimultaneousUse";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class QueryControlFlagBits : VkQueryControlFlags {
+  ePrecise = VK_QUERY_CONTROL_PRECISE_BIT
+};
+
+VULKAN_HPP_INLINE std::string to_string(QueryControlFlagBits value) {
+  switch (value) {
+  case QueryControlFlagBits::ePrecise:
+    return "Precise";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class IndexType {
+  eUint16 = VK_INDEX_TYPE_UINT16,
+  eUint32 = VK_INDEX_TYPE_UINT32,
+  eNoneKHR = VK_INDEX_TYPE_NONE_KHR,
+  eUint8EXT = VK_INDEX_TYPE_UINT8_EXT,
+  eNoneNV = VK_INDEX_TYPE_NONE_NV
+};
+
+VULKAN_HPP_INLINE std::string to_string(IndexType value) {
+  switch (value) {
+  case IndexType::eUint16:
+    return "Uint16";
+  case IndexType::eUint32:
+    return "Uint32";
+  case IndexType::eNoneKHR:
+    return "NoneKHR";
+  case IndexType::eUint8EXT:
+    return "Uint8EXT";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class StencilFaceFlagBits : VkStencilFaceFlags {
+  eFront = VK_STENCIL_FACE_FRONT_BIT,
+  eBack = VK_STENCIL_FACE_BACK_BIT,
+  eFrontAndBack = VK_STENCIL_FACE_FRONT_AND_BACK,
+  eVkStencilFrontAndBack = VK_STENCIL_FRONT_AND_BACK
+};
+
+VULKAN_HPP_INLINE std::string to_string(StencilFaceFlagBits value) {
+  switch (value) {
+  case StencilFaceFlagBits::eFront:
+    return "Front";
+  case StencilFaceFlagBits::eBack:
+    return "Back";
+  case StencilFaceFlagBits::eFrontAndBack:
+    return "FrontAndBack";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class SubpassContents {
+  eInline = VK_SUBPASS_CONTENTS_INLINE,
+  eSecondaryCommandBuffers = VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS
+};
+
+VULKAN_HPP_INLINE std::string to_string(SubpassContents value) {
+  switch (value) {
+  case SubpassContents::eInline:
+    return "Inline";
+  case SubpassContents::eSecondaryCommandBuffers:
+    return "SecondaryCommandBuffers";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+//=== VK_VERSION_1_1 ===
+
 enum class SubgroupFeatureFlagBits : VkSubgroupFeatureFlags {
   eBasic = VK_SUBGROUP_FEATURE_BASIC_BIT,
   eVote = VK_SUBGROUP_FEATURE_VOTE_BIT,
@@ -12967,14 +11252,24 @@
   }
 }
 
-enum class SubmitFlagBitsKHR : VkSubmitFlagsKHR {
-  eProtected = VK_SUBMIT_PROTECTED_BIT_KHR
+enum class PeerMemoryFeatureFlagBits : VkPeerMemoryFeatureFlags {
+  eCopySrc = VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT,
+  eCopyDst = VK_PEER_MEMORY_FEATURE_COPY_DST_BIT,
+  eGenericSrc = VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT,
+  eGenericDst = VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT
 };
+using PeerMemoryFeatureFlagBitsKHR = PeerMemoryFeatureFlagBits;
 
-VULKAN_HPP_INLINE std::string to_string(SubmitFlagBitsKHR value) {
+VULKAN_HPP_INLINE std::string to_string(PeerMemoryFeatureFlagBits value) {
   switch (value) {
-  case SubmitFlagBitsKHR::eProtected:
-    return "Protected";
+  case PeerMemoryFeatureFlagBits::eCopySrc:
+    return "CopySrc";
+  case PeerMemoryFeatureFlagBits::eCopyDst:
+    return "CopyDst";
+  case PeerMemoryFeatureFlagBits::eGenericSrc:
+    return "GenericSrc";
+  case PeerMemoryFeatureFlagBits::eGenericDst:
+    return "GenericDst";
   default:
     return "invalid ( " +
            VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
@@ -12982,17 +11277,22 @@
   }
 }
 
-enum class SubpassContents {
-  eInline = VK_SUBPASS_CONTENTS_INLINE,
-  eSecondaryCommandBuffers = VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS
+enum class MemoryAllocateFlagBits : VkMemoryAllocateFlags {
+  eDeviceMask = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT,
+  eDeviceAddress = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT,
+  eDeviceAddressCaptureReplay =
+      VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT
 };
+using MemoryAllocateFlagBitsKHR = MemoryAllocateFlagBits;
 
-VULKAN_HPP_INLINE std::string to_string(SubpassContents value) {
+VULKAN_HPP_INLINE std::string to_string(MemoryAllocateFlagBits value) {
   switch (value) {
-  case SubpassContents::eInline:
-    return "Inline";
-  case SubpassContents::eSecondaryCommandBuffers:
-    return "SecondaryCommandBuffers";
+  case MemoryAllocateFlagBits::eDeviceMask:
+    return "DeviceMask";
+  case MemoryAllocateFlagBits::eDeviceAddress:
+    return "DeviceAddress";
+  case MemoryAllocateFlagBits::eDeviceAddressCaptureReplay:
+    return "DeviceAddressCaptureReplay";
   default:
     return "invalid ( " +
            VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
@@ -13000,24 +11300,18 @@
   }
 }
 
-enum class SubpassDescriptionFlagBits : VkSubpassDescriptionFlags {
-  ePerViewAttributesNVX = VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX,
-  ePerViewPositionXOnlyNVX =
-      VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX,
-  eFragmentRegionQCOM = VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM,
-  eShaderResolveQCOM = VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM
+enum class PointClippingBehavior {
+  eAllClipPlanes = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES,
+  eUserClipPlanesOnly = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY
 };
+using PointClippingBehaviorKHR = PointClippingBehavior;
 
-VULKAN_HPP_INLINE std::string to_string(SubpassDescriptionFlagBits value) {
+VULKAN_HPP_INLINE std::string to_string(PointClippingBehavior value) {
   switch (value) {
-  case SubpassDescriptionFlagBits::ePerViewAttributesNVX:
-    return "PerViewAttributesNVX";
-  case SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX:
-    return "PerViewPositionXOnlyNVX";
-  case SubpassDescriptionFlagBits::eFragmentRegionQCOM:
-    return "FragmentRegionQCOM";
-  case SubpassDescriptionFlagBits::eShaderResolveQCOM:
-    return "ShaderResolveQCOM";
+  case PointClippingBehavior::eAllClipPlanes:
+    return "AllClipPlanes";
+  case PointClippingBehavior::eUserClipPlanesOnly:
+    return "UserClipPlanesOnly";
   default:
     return "invalid ( " +
            VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
@@ -13025,14 +11319,18 @@
   }
 }
 
-enum class SurfaceCounterFlagBitsEXT : VkSurfaceCounterFlagsEXT {
-  eVblank = VK_SURFACE_COUNTER_VBLANK_BIT_EXT
+enum class TessellationDomainOrigin {
+  eUpperLeft = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT,
+  eLowerLeft = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT
 };
+using TessellationDomainOriginKHR = TessellationDomainOrigin;
 
-VULKAN_HPP_INLINE std::string to_string(SurfaceCounterFlagBitsEXT value) {
+VULKAN_HPP_INLINE std::string to_string(TessellationDomainOrigin value) {
   switch (value) {
-  case SurfaceCounterFlagBitsEXT::eVblank:
-    return "Vblank";
+  case TessellationDomainOrigin::eUpperLeft:
+    return "UpperLeft";
+  case TessellationDomainOrigin::eLowerLeft:
+    return "LowerLeft";
   default:
     return "invalid ( " +
            VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
@@ -13040,6 +11338,502 @@
   }
 }
 
+enum class SamplerYcbcrModelConversion {
+  eRgbIdentity = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY,
+  eYcbcrIdentity = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY,
+  eYcbcr709 = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709,
+  eYcbcr601 = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601,
+  eYcbcr2020 = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020
+};
+using SamplerYcbcrModelConversionKHR = SamplerYcbcrModelConversion;
+
+VULKAN_HPP_INLINE std::string to_string(SamplerYcbcrModelConversion value) {
+  switch (value) {
+  case SamplerYcbcrModelConversion::eRgbIdentity:
+    return "RgbIdentity";
+  case SamplerYcbcrModelConversion::eYcbcrIdentity:
+    return "YcbcrIdentity";
+  case SamplerYcbcrModelConversion::eYcbcr709:
+    return "Ycbcr709";
+  case SamplerYcbcrModelConversion::eYcbcr601:
+    return "Ycbcr601";
+  case SamplerYcbcrModelConversion::eYcbcr2020:
+    return "Ycbcr2020";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class SamplerYcbcrRange {
+  eItuFull = VK_SAMPLER_YCBCR_RANGE_ITU_FULL,
+  eItuNarrow = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW
+};
+using SamplerYcbcrRangeKHR = SamplerYcbcrRange;
+
+VULKAN_HPP_INLINE std::string to_string(SamplerYcbcrRange value) {
+  switch (value) {
+  case SamplerYcbcrRange::eItuFull:
+    return "ItuFull";
+  case SamplerYcbcrRange::eItuNarrow:
+    return "ItuNarrow";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class ChromaLocation {
+  eCositedEven = VK_CHROMA_LOCATION_COSITED_EVEN,
+  eMidpoint = VK_CHROMA_LOCATION_MIDPOINT
+};
+using ChromaLocationKHR = ChromaLocation;
+
+VULKAN_HPP_INLINE std::string to_string(ChromaLocation value) {
+  switch (value) {
+  case ChromaLocation::eCositedEven:
+    return "CositedEven";
+  case ChromaLocation::eMidpoint:
+    return "Midpoint";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class DescriptorUpdateTemplateType {
+  eDescriptorSet = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET,
+  ePushDescriptorsKHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR
+};
+using DescriptorUpdateTemplateTypeKHR = DescriptorUpdateTemplateType;
+
+VULKAN_HPP_INLINE std::string to_string(DescriptorUpdateTemplateType value) {
+  switch (value) {
+  case DescriptorUpdateTemplateType::eDescriptorSet:
+    return "DescriptorSet";
+  case DescriptorUpdateTemplateType::ePushDescriptorsKHR:
+    return "PushDescriptorsKHR";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class ExternalMemoryHandleTypeFlagBits : VkExternalMemoryHandleTypeFlags {
+  eOpaqueFd = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT,
+  eOpaqueWin32 = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT,
+  eOpaqueWin32Kmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
+  eD3D11Texture = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT,
+  eD3D11TextureKmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT,
+  eD3D12Heap = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT,
+  eD3D12Resource = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT,
+  eDmaBufEXT = VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT,
+#if defined(VK_USE_PLATFORM_ANDROID_KHR)
+  eAndroidHardwareBufferANDROID =
+      VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID,
+#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+  eHostAllocationEXT = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT,
+  eHostMappedForeignMemoryEXT =
+      VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT,
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+  eZirconVmoFUCHSIA = VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+};
+using ExternalMemoryHandleTypeFlagBitsKHR = ExternalMemoryHandleTypeFlagBits;
+
+VULKAN_HPP_INLINE std::string
+to_string(ExternalMemoryHandleTypeFlagBits value) {
+  switch (value) {
+  case ExternalMemoryHandleTypeFlagBits::eOpaqueFd:
+    return "OpaqueFd";
+  case ExternalMemoryHandleTypeFlagBits::eOpaqueWin32:
+    return "OpaqueWin32";
+  case ExternalMemoryHandleTypeFlagBits::eOpaqueWin32Kmt:
+    return "OpaqueWin32Kmt";
+  case ExternalMemoryHandleTypeFlagBits::eD3D11Texture:
+    return "D3D11Texture";
+  case ExternalMemoryHandleTypeFlagBits::eD3D11TextureKmt:
+    return "D3D11TextureKmt";
+  case ExternalMemoryHandleTypeFlagBits::eD3D12Heap:
+    return "D3D12Heap";
+  case ExternalMemoryHandleTypeFlagBits::eD3D12Resource:
+    return "D3D12Resource";
+  case ExternalMemoryHandleTypeFlagBits::eDmaBufEXT:
+    return "DmaBufEXT";
+#if defined(VK_USE_PLATFORM_ANDROID_KHR)
+  case ExternalMemoryHandleTypeFlagBits::eAndroidHardwareBufferANDROID:
+    return "AndroidHardwareBufferANDROID";
+#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+  case ExternalMemoryHandleTypeFlagBits::eHostAllocationEXT:
+    return "HostAllocationEXT";
+  case ExternalMemoryHandleTypeFlagBits::eHostMappedForeignMemoryEXT:
+    return "HostMappedForeignMemoryEXT";
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+  case ExternalMemoryHandleTypeFlagBits::eZirconVmoFUCHSIA:
+    return "ZirconVmoFUCHSIA";
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class ExternalMemoryFeatureFlagBits : VkExternalMemoryFeatureFlags {
+  eDedicatedOnly = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT,
+  eExportable = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT,
+  eImportable = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT
+};
+using ExternalMemoryFeatureFlagBitsKHR = ExternalMemoryFeatureFlagBits;
+
+VULKAN_HPP_INLINE std::string to_string(ExternalMemoryFeatureFlagBits value) {
+  switch (value) {
+  case ExternalMemoryFeatureFlagBits::eDedicatedOnly:
+    return "DedicatedOnly";
+  case ExternalMemoryFeatureFlagBits::eExportable:
+    return "Exportable";
+  case ExternalMemoryFeatureFlagBits::eImportable:
+    return "Importable";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class ExternalFenceHandleTypeFlagBits : VkExternalFenceHandleTypeFlags {
+  eOpaqueFd = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT,
+  eOpaqueWin32 = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT,
+  eOpaqueWin32Kmt = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
+  eSyncFd = VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT
+};
+using ExternalFenceHandleTypeFlagBitsKHR = ExternalFenceHandleTypeFlagBits;
+
+VULKAN_HPP_INLINE std::string to_string(ExternalFenceHandleTypeFlagBits value) {
+  switch (value) {
+  case ExternalFenceHandleTypeFlagBits::eOpaqueFd:
+    return "OpaqueFd";
+  case ExternalFenceHandleTypeFlagBits::eOpaqueWin32:
+    return "OpaqueWin32";
+  case ExternalFenceHandleTypeFlagBits::eOpaqueWin32Kmt:
+    return "OpaqueWin32Kmt";
+  case ExternalFenceHandleTypeFlagBits::eSyncFd:
+    return "SyncFd";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class ExternalFenceFeatureFlagBits : VkExternalFenceFeatureFlags {
+  eExportable = VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT,
+  eImportable = VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT
+};
+using ExternalFenceFeatureFlagBitsKHR = ExternalFenceFeatureFlagBits;
+
+VULKAN_HPP_INLINE std::string to_string(ExternalFenceFeatureFlagBits value) {
+  switch (value) {
+  case ExternalFenceFeatureFlagBits::eExportable:
+    return "Exportable";
+  case ExternalFenceFeatureFlagBits::eImportable:
+    return "Importable";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class FenceImportFlagBits : VkFenceImportFlags {
+  eTemporary = VK_FENCE_IMPORT_TEMPORARY_BIT
+};
+using FenceImportFlagBitsKHR = FenceImportFlagBits;
+
+VULKAN_HPP_INLINE std::string to_string(FenceImportFlagBits value) {
+  switch (value) {
+  case FenceImportFlagBits::eTemporary:
+    return "Temporary";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class SemaphoreImportFlagBits : VkSemaphoreImportFlags {
+  eTemporary = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT
+};
+using SemaphoreImportFlagBitsKHR = SemaphoreImportFlagBits;
+
+VULKAN_HPP_INLINE std::string to_string(SemaphoreImportFlagBits value) {
+  switch (value) {
+  case SemaphoreImportFlagBits::eTemporary:
+    return "Temporary";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class
+    ExternalSemaphoreHandleTypeFlagBits : VkExternalSemaphoreHandleTypeFlags {
+      eOpaqueFd = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT,
+      eOpaqueWin32 = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT,
+      eOpaqueWin32Kmt = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
+      eD3D12Fence = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT,
+      eSyncFd = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT,
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+      eZirconEventFUCHSIA =
+          VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA,
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+      eD3D11Fence = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE_BIT
+    };
+using ExternalSemaphoreHandleTypeFlagBitsKHR =
+    ExternalSemaphoreHandleTypeFlagBits;
+
+VULKAN_HPP_INLINE std::string
+to_string(ExternalSemaphoreHandleTypeFlagBits value) {
+  switch (value) {
+  case ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd:
+    return "OpaqueFd";
+  case ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32:
+    return "OpaqueWin32";
+  case ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32Kmt:
+    return "OpaqueWin32Kmt";
+  case ExternalSemaphoreHandleTypeFlagBits::eD3D12Fence:
+    return "D3D12Fence";
+  case ExternalSemaphoreHandleTypeFlagBits::eSyncFd:
+    return "SyncFd";
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+  case ExternalSemaphoreHandleTypeFlagBits::eZirconEventFUCHSIA:
+    return "ZirconEventFUCHSIA";
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class ExternalSemaphoreFeatureFlagBits : VkExternalSemaphoreFeatureFlags {
+  eExportable = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT,
+  eImportable = VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT
+};
+using ExternalSemaphoreFeatureFlagBitsKHR = ExternalSemaphoreFeatureFlagBits;
+
+VULKAN_HPP_INLINE std::string
+to_string(ExternalSemaphoreFeatureFlagBits value) {
+  switch (value) {
+  case ExternalSemaphoreFeatureFlagBits::eExportable:
+    return "Exportable";
+  case ExternalSemaphoreFeatureFlagBits::eImportable:
+    return "Importable";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+//=== VK_VERSION_1_2 ===
+
+enum class DriverId {
+  eAmdProprietary = VK_DRIVER_ID_AMD_PROPRIETARY,
+  eAmdOpenSource = VK_DRIVER_ID_AMD_OPEN_SOURCE,
+  eMesaRadv = VK_DRIVER_ID_MESA_RADV,
+  eNvidiaProprietary = VK_DRIVER_ID_NVIDIA_PROPRIETARY,
+  eIntelProprietaryWindows = VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS,
+  eIntelOpenSourceMESA = VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA,
+  eImaginationProprietary = VK_DRIVER_ID_IMAGINATION_PROPRIETARY,
+  eQualcommProprietary = VK_DRIVER_ID_QUALCOMM_PROPRIETARY,
+  eArmProprietary = VK_DRIVER_ID_ARM_PROPRIETARY,
+  eGoogleSwiftshader = VK_DRIVER_ID_GOOGLE_SWIFTSHADER,
+  eGgpProprietary = VK_DRIVER_ID_GGP_PROPRIETARY,
+  eBroadcomProprietary = VK_DRIVER_ID_BROADCOM_PROPRIETARY,
+  eMesaLlvmpipe = VK_DRIVER_ID_MESA_LLVMPIPE,
+  eMoltenvk = VK_DRIVER_ID_MOLTENVK,
+  eIntelOpenSourceMesa = VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA_KHR
+};
+using DriverIdKHR = DriverId;
+
+VULKAN_HPP_INLINE std::string to_string(DriverId value) {
+  switch (value) {
+  case DriverId::eAmdProprietary:
+    return "AmdProprietary";
+  case DriverId::eAmdOpenSource:
+    return "AmdOpenSource";
+  case DriverId::eMesaRadv:
+    return "MesaRadv";
+  case DriverId::eNvidiaProprietary:
+    return "NvidiaProprietary";
+  case DriverId::eIntelProprietaryWindows:
+    return "IntelProprietaryWindows";
+  case DriverId::eIntelOpenSourceMESA:
+    return "IntelOpenSourceMESA";
+  case DriverId::eImaginationProprietary:
+    return "ImaginationProprietary";
+  case DriverId::eQualcommProprietary:
+    return "QualcommProprietary";
+  case DriverId::eArmProprietary:
+    return "ArmProprietary";
+  case DriverId::eGoogleSwiftshader:
+    return "GoogleSwiftshader";
+  case DriverId::eGgpProprietary:
+    return "GgpProprietary";
+  case DriverId::eBroadcomProprietary:
+    return "BroadcomProprietary";
+  case DriverId::eMesaLlvmpipe:
+    return "MesaLlvmpipe";
+  case DriverId::eMoltenvk:
+    return "Moltenvk";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class ShaderFloatControlsIndependence {
+  e32BitOnly = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY,
+  eAll = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL,
+  eNone = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE
+};
+using ShaderFloatControlsIndependenceKHR = ShaderFloatControlsIndependence;
+
+VULKAN_HPP_INLINE std::string to_string(ShaderFloatControlsIndependence value) {
+  switch (value) {
+  case ShaderFloatControlsIndependence::e32BitOnly:
+    return "32BitOnly";
+  case ShaderFloatControlsIndependence::eAll:
+    return "All";
+  case ShaderFloatControlsIndependence::eNone:
+    return "None";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class DescriptorBindingFlagBits : VkDescriptorBindingFlags {
+  eUpdateAfterBind = VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT,
+  eUpdateUnusedWhilePending =
+      VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT,
+  ePartiallyBound = VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT,
+  eVariableDescriptorCount = VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT
+};
+using DescriptorBindingFlagBitsEXT = DescriptorBindingFlagBits;
+
+VULKAN_HPP_INLINE std::string to_string(DescriptorBindingFlagBits value) {
+  switch (value) {
+  case DescriptorBindingFlagBits::eUpdateAfterBind:
+    return "UpdateAfterBind";
+  case DescriptorBindingFlagBits::eUpdateUnusedWhilePending:
+    return "UpdateUnusedWhilePending";
+  case DescriptorBindingFlagBits::ePartiallyBound:
+    return "PartiallyBound";
+  case DescriptorBindingFlagBits::eVariableDescriptorCount:
+    return "VariableDescriptorCount";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class ResolveModeFlagBits : VkResolveModeFlags {
+  eNone = VK_RESOLVE_MODE_NONE,
+  eSampleZero = VK_RESOLVE_MODE_SAMPLE_ZERO_BIT,
+  eAverage = VK_RESOLVE_MODE_AVERAGE_BIT,
+  eMin = VK_RESOLVE_MODE_MIN_BIT,
+  eMax = VK_RESOLVE_MODE_MAX_BIT
+};
+using ResolveModeFlagBitsKHR = ResolveModeFlagBits;
+
+VULKAN_HPP_INLINE std::string to_string(ResolveModeFlagBits value) {
+  switch (value) {
+  case ResolveModeFlagBits::eNone:
+    return "None";
+  case ResolveModeFlagBits::eSampleZero:
+    return "SampleZero";
+  case ResolveModeFlagBits::eAverage:
+    return "Average";
+  case ResolveModeFlagBits::eMin:
+    return "Min";
+  case ResolveModeFlagBits::eMax:
+    return "Max";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class SamplerReductionMode {
+  eWeightedAverage = VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE,
+  eMin = VK_SAMPLER_REDUCTION_MODE_MIN,
+  eMax = VK_SAMPLER_REDUCTION_MODE_MAX
+};
+using SamplerReductionModeEXT = SamplerReductionMode;
+
+VULKAN_HPP_INLINE std::string to_string(SamplerReductionMode value) {
+  switch (value) {
+  case SamplerReductionMode::eWeightedAverage:
+    return "WeightedAverage";
+  case SamplerReductionMode::eMin:
+    return "Min";
+  case SamplerReductionMode::eMax:
+    return "Max";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class SemaphoreType {
+  eBinary = VK_SEMAPHORE_TYPE_BINARY,
+  eTimeline = VK_SEMAPHORE_TYPE_TIMELINE
+};
+using SemaphoreTypeKHR = SemaphoreType;
+
+VULKAN_HPP_INLINE std::string to_string(SemaphoreType value) {
+  switch (value) {
+  case SemaphoreType::eBinary:
+    return "Binary";
+  case SemaphoreType::eTimeline:
+    return "Timeline";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class SemaphoreWaitFlagBits : VkSemaphoreWaitFlags {
+  eAny = VK_SEMAPHORE_WAIT_ANY_BIT
+};
+using SemaphoreWaitFlagBitsKHR = SemaphoreWaitFlagBits;
+
+VULKAN_HPP_INLINE std::string to_string(SemaphoreWaitFlagBits value) {
+  switch (value) {
+  case SemaphoreWaitFlagBits::eAny:
+    return "Any";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+//=== VK_KHR_surface ===
+
 enum class SurfaceTransformFlagBitsKHR : VkSurfaceTransformFlagsKHR {
   eIdentity = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR,
   eRotate90 = VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR,
@@ -13082,6 +11876,124 @@
   }
 }
 
+enum class PresentModeKHR {
+  eImmediate = VK_PRESENT_MODE_IMMEDIATE_KHR,
+  eMailbox = VK_PRESENT_MODE_MAILBOX_KHR,
+  eFifo = VK_PRESENT_MODE_FIFO_KHR,
+  eFifoRelaxed = VK_PRESENT_MODE_FIFO_RELAXED_KHR,
+  eSharedDemandRefresh = VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR,
+  eSharedContinuousRefresh = VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR
+};
+
+VULKAN_HPP_INLINE std::string to_string(PresentModeKHR value) {
+  switch (value) {
+  case PresentModeKHR::eImmediate:
+    return "Immediate";
+  case PresentModeKHR::eMailbox:
+    return "Mailbox";
+  case PresentModeKHR::eFifo:
+    return "Fifo";
+  case PresentModeKHR::eFifoRelaxed:
+    return "FifoRelaxed";
+  case PresentModeKHR::eSharedDemandRefresh:
+    return "SharedDemandRefresh";
+  case PresentModeKHR::eSharedContinuousRefresh:
+    return "SharedContinuousRefresh";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class ColorSpaceKHR {
+  eSrgbNonlinear = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR,
+  eDisplayP3NonlinearEXT = VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT,
+  eExtendedSrgbLinearEXT = VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT,
+  eDisplayP3LinearEXT = VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT,
+  eDciP3NonlinearEXT = VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT,
+  eBt709LinearEXT = VK_COLOR_SPACE_BT709_LINEAR_EXT,
+  eBt709NonlinearEXT = VK_COLOR_SPACE_BT709_NONLINEAR_EXT,
+  eBt2020LinearEXT = VK_COLOR_SPACE_BT2020_LINEAR_EXT,
+  eHdr10St2084EXT = VK_COLOR_SPACE_HDR10_ST2084_EXT,
+  eDolbyvisionEXT = VK_COLOR_SPACE_DOLBYVISION_EXT,
+  eHdr10HlgEXT = VK_COLOR_SPACE_HDR10_HLG_EXT,
+  eAdobergbLinearEXT = VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT,
+  eAdobergbNonlinearEXT = VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT,
+  ePassThroughEXT = VK_COLOR_SPACE_PASS_THROUGH_EXT,
+  eExtendedSrgbNonlinearEXT = VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT,
+  eDisplayNativeAMD = VK_COLOR_SPACE_DISPLAY_NATIVE_AMD,
+  eVkColorspaceSrgbNonlinear = VK_COLORSPACE_SRGB_NONLINEAR_KHR,
+  eDciP3LinearEXT = VK_COLOR_SPACE_DCI_P3_LINEAR_EXT
+};
+
+VULKAN_HPP_INLINE std::string to_string(ColorSpaceKHR value) {
+  switch (value) {
+  case ColorSpaceKHR::eSrgbNonlinear:
+    return "SrgbNonlinear";
+  case ColorSpaceKHR::eDisplayP3NonlinearEXT:
+    return "DisplayP3NonlinearEXT";
+  case ColorSpaceKHR::eExtendedSrgbLinearEXT:
+    return "ExtendedSrgbLinearEXT";
+  case ColorSpaceKHR::eDisplayP3LinearEXT:
+    return "DisplayP3LinearEXT";
+  case ColorSpaceKHR::eDciP3NonlinearEXT:
+    return "DciP3NonlinearEXT";
+  case ColorSpaceKHR::eBt709LinearEXT:
+    return "Bt709LinearEXT";
+  case ColorSpaceKHR::eBt709NonlinearEXT:
+    return "Bt709NonlinearEXT";
+  case ColorSpaceKHR::eBt2020LinearEXT:
+    return "Bt2020LinearEXT";
+  case ColorSpaceKHR::eHdr10St2084EXT:
+    return "Hdr10St2084EXT";
+  case ColorSpaceKHR::eDolbyvisionEXT:
+    return "DolbyvisionEXT";
+  case ColorSpaceKHR::eHdr10HlgEXT:
+    return "Hdr10HlgEXT";
+  case ColorSpaceKHR::eAdobergbLinearEXT:
+    return "AdobergbLinearEXT";
+  case ColorSpaceKHR::eAdobergbNonlinearEXT:
+    return "AdobergbNonlinearEXT";
+  case ColorSpaceKHR::ePassThroughEXT:
+    return "PassThroughEXT";
+  case ColorSpaceKHR::eExtendedSrgbNonlinearEXT:
+    return "ExtendedSrgbNonlinearEXT";
+  case ColorSpaceKHR::eDisplayNativeAMD:
+    return "DisplayNativeAMD";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class CompositeAlphaFlagBitsKHR : VkCompositeAlphaFlagsKHR {
+  eOpaque = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR,
+  ePreMultiplied = VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR,
+  ePostMultiplied = VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR,
+  eInherit = VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR
+};
+
+VULKAN_HPP_INLINE std::string to_string(CompositeAlphaFlagBitsKHR value) {
+  switch (value) {
+  case CompositeAlphaFlagBitsKHR::eOpaque:
+    return "Opaque";
+  case CompositeAlphaFlagBitsKHR::ePreMultiplied:
+    return "PreMultiplied";
+  case CompositeAlphaFlagBitsKHR::ePostMultiplied:
+    return "PostMultiplied";
+  case CompositeAlphaFlagBitsKHR::eInherit:
+    return "Inherit";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+//=== VK_KHR_swapchain ===
+
 enum class SwapchainCreateFlagBitsKHR : VkSwapchainCreateFlagsKHR {
   eSplitInstanceBindRegions =
       VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR,
@@ -13104,26 +12016,225 @@
   }
 }
 
-enum class SystemAllocationScope {
-  eCommand = VK_SYSTEM_ALLOCATION_SCOPE_COMMAND,
-  eObject = VK_SYSTEM_ALLOCATION_SCOPE_OBJECT,
-  eCache = VK_SYSTEM_ALLOCATION_SCOPE_CACHE,
-  eDevice = VK_SYSTEM_ALLOCATION_SCOPE_DEVICE,
-  eInstance = VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE
+enum class
+    DeviceGroupPresentModeFlagBitsKHR : VkDeviceGroupPresentModeFlagsKHR {
+      eLocal = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR,
+      eRemote = VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR,
+      eSum = VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR,
+      eLocalMultiDevice =
+          VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR
+    };
+
+VULKAN_HPP_INLINE std::string
+to_string(DeviceGroupPresentModeFlagBitsKHR value) {
+  switch (value) {
+  case DeviceGroupPresentModeFlagBitsKHR::eLocal:
+    return "Local";
+  case DeviceGroupPresentModeFlagBitsKHR::eRemote:
+    return "Remote";
+  case DeviceGroupPresentModeFlagBitsKHR::eSum:
+    return "Sum";
+  case DeviceGroupPresentModeFlagBitsKHR::eLocalMultiDevice:
+    return "LocalMultiDevice";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+//=== VK_KHR_display ===
+
+enum class DisplayPlaneAlphaFlagBitsKHR : VkDisplayPlaneAlphaFlagsKHR {
+  eOpaque = VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR,
+  eGlobal = VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR,
+  ePerPixel = VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR,
+  ePerPixelPremultiplied =
+      VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR
 };
 
-VULKAN_HPP_INLINE std::string to_string(SystemAllocationScope value) {
+VULKAN_HPP_INLINE std::string to_string(DisplayPlaneAlphaFlagBitsKHR value) {
   switch (value) {
-  case SystemAllocationScope::eCommand:
-    return "Command";
-  case SystemAllocationScope::eObject:
-    return "Object";
-  case SystemAllocationScope::eCache:
-    return "Cache";
-  case SystemAllocationScope::eDevice:
-    return "Device";
-  case SystemAllocationScope::eInstance:
+  case DisplayPlaneAlphaFlagBitsKHR::eOpaque:
+    return "Opaque";
+  case DisplayPlaneAlphaFlagBitsKHR::eGlobal:
+    return "Global";
+  case DisplayPlaneAlphaFlagBitsKHR::ePerPixel:
+    return "PerPixel";
+  case DisplayPlaneAlphaFlagBitsKHR::ePerPixelPremultiplied:
+    return "PerPixelPremultiplied";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+//=== VK_EXT_debug_report ===
+
+enum class DebugReportFlagBitsEXT : VkDebugReportFlagsEXT {
+  eInformation = VK_DEBUG_REPORT_INFORMATION_BIT_EXT,
+  eWarning = VK_DEBUG_REPORT_WARNING_BIT_EXT,
+  ePerformanceWarning = VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT,
+  eError = VK_DEBUG_REPORT_ERROR_BIT_EXT,
+  eDebug = VK_DEBUG_REPORT_DEBUG_BIT_EXT
+};
+
+VULKAN_HPP_INLINE std::string to_string(DebugReportFlagBitsEXT value) {
+  switch (value) {
+  case DebugReportFlagBitsEXT::eInformation:
+    return "Information";
+  case DebugReportFlagBitsEXT::eWarning:
+    return "Warning";
+  case DebugReportFlagBitsEXT::ePerformanceWarning:
+    return "PerformanceWarning";
+  case DebugReportFlagBitsEXT::eError:
+    return "Error";
+  case DebugReportFlagBitsEXT::eDebug:
+    return "Debug";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class DebugReportObjectTypeEXT {
+  eUnknown = VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT,
+  eInstance = VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT,
+  ePhysicalDevice = VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT,
+  eDevice = VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT,
+  eQueue = VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT,
+  eSemaphore = VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT,
+  eCommandBuffer = VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
+  eFence = VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT,
+  eDeviceMemory = VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT,
+  eBuffer = VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT,
+  eImage = VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
+  eEvent = VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT,
+  eQueryPool = VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT,
+  eBufferView = VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT,
+  eImageView = VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT,
+  eShaderModule = VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT,
+  ePipelineCache = VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT,
+  ePipelineLayout = VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT,
+  eRenderPass = VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT,
+  ePipeline = VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT,
+  eDescriptorSetLayout = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT,
+  eSampler = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT,
+  eDescriptorPool = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT,
+  eDescriptorSet = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT,
+  eFramebuffer = VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT,
+  eCommandPool = VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT,
+  eSurfaceKHR = VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT,
+  eSwapchainKHR = VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT,
+  eDebugReportCallbackEXT =
+      VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT,
+  eDisplayKHR = VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT,
+  eDisplayModeKHR = VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT,
+  eValidationCacheEXT = VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT,
+  eSamplerYcbcrConversion =
+      VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT,
+  eDescriptorUpdateTemplate =
+      VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT,
+  eAccelerationStructureKHR =
+      VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR_EXT,
+  eAccelerationStructureNV =
+      VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT,
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+  eBufferCollectionFUCHSIA =
+      VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA_EXT,
+  eBufferCollectionFuchsiax =
+      VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIAX_EXT,
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+  eDebugReport = VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT,
+  eDescriptorUpdateTemplateKHR =
+      VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT,
+  eSamplerYcbcrConversionKHR =
+      VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR_EXT,
+  eValidationCache = VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT
+};
+
+VULKAN_HPP_INLINE std::string to_string(DebugReportObjectTypeEXT value) {
+  switch (value) {
+  case DebugReportObjectTypeEXT::eUnknown:
+    return "Unknown";
+  case DebugReportObjectTypeEXT::eInstance:
     return "Instance";
+  case DebugReportObjectTypeEXT::ePhysicalDevice:
+    return "PhysicalDevice";
+  case DebugReportObjectTypeEXT::eDevice:
+    return "Device";
+  case DebugReportObjectTypeEXT::eQueue:
+    return "Queue";
+  case DebugReportObjectTypeEXT::eSemaphore:
+    return "Semaphore";
+  case DebugReportObjectTypeEXT::eCommandBuffer:
+    return "CommandBuffer";
+  case DebugReportObjectTypeEXT::eFence:
+    return "Fence";
+  case DebugReportObjectTypeEXT::eDeviceMemory:
+    return "DeviceMemory";
+  case DebugReportObjectTypeEXT::eBuffer:
+    return "Buffer";
+  case DebugReportObjectTypeEXT::eImage:
+    return "Image";
+  case DebugReportObjectTypeEXT::eEvent:
+    return "Event";
+  case DebugReportObjectTypeEXT::eQueryPool:
+    return "QueryPool";
+  case DebugReportObjectTypeEXT::eBufferView:
+    return "BufferView";
+  case DebugReportObjectTypeEXT::eImageView:
+    return "ImageView";
+  case DebugReportObjectTypeEXT::eShaderModule:
+    return "ShaderModule";
+  case DebugReportObjectTypeEXT::ePipelineCache:
+    return "PipelineCache";
+  case DebugReportObjectTypeEXT::ePipelineLayout:
+    return "PipelineLayout";
+  case DebugReportObjectTypeEXT::eRenderPass:
+    return "RenderPass";
+  case DebugReportObjectTypeEXT::ePipeline:
+    return "Pipeline";
+  case DebugReportObjectTypeEXT::eDescriptorSetLayout:
+    return "DescriptorSetLayout";
+  case DebugReportObjectTypeEXT::eSampler:
+    return "Sampler";
+  case DebugReportObjectTypeEXT::eDescriptorPool:
+    return "DescriptorPool";
+  case DebugReportObjectTypeEXT::eDescriptorSet:
+    return "DescriptorSet";
+  case DebugReportObjectTypeEXT::eFramebuffer:
+    return "Framebuffer";
+  case DebugReportObjectTypeEXT::eCommandPool:
+    return "CommandPool";
+  case DebugReportObjectTypeEXT::eSurfaceKHR:
+    return "SurfaceKHR";
+  case DebugReportObjectTypeEXT::eSwapchainKHR:
+    return "SwapchainKHR";
+  case DebugReportObjectTypeEXT::eDebugReportCallbackEXT:
+    return "DebugReportCallbackEXT";
+  case DebugReportObjectTypeEXT::eDisplayKHR:
+    return "DisplayKHR";
+  case DebugReportObjectTypeEXT::eDisplayModeKHR:
+    return "DisplayModeKHR";
+  case DebugReportObjectTypeEXT::eValidationCacheEXT:
+    return "ValidationCacheEXT";
+  case DebugReportObjectTypeEXT::eSamplerYcbcrConversion:
+    return "SamplerYcbcrConversion";
+  case DebugReportObjectTypeEXT::eDescriptorUpdateTemplate:
+    return "DescriptorUpdateTemplate";
+  case DebugReportObjectTypeEXT::eAccelerationStructureKHR:
+    return "AccelerationStructureKHR";
+  case DebugReportObjectTypeEXT::eAccelerationStructureNV:
+    return "AccelerationStructureNV";
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+  case DebugReportObjectTypeEXT::eBufferCollectionFUCHSIA:
+    return "BufferCollectionFUCHSIA";
+  case DebugReportObjectTypeEXT::eBufferCollectionFuchsiax:
+    return "BufferCollectionFuchsiax";
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
   default:
     return "invalid ( " +
            VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
@@ -13131,18 +12242,19 @@
   }
 }
 
-enum class TessellationDomainOrigin {
-  eUpperLeft = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT,
-  eLowerLeft = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT
+//=== VK_AMD_rasterization_order ===
+
+enum class RasterizationOrderAMD {
+  eStrict = VK_RASTERIZATION_ORDER_STRICT_AMD,
+  eRelaxed = VK_RASTERIZATION_ORDER_RELAXED_AMD
 };
-using TessellationDomainOriginKHR = TessellationDomainOrigin;
 
-VULKAN_HPP_INLINE std::string to_string(TessellationDomainOrigin value) {
+VULKAN_HPP_INLINE std::string to_string(RasterizationOrderAMD value) {
   switch (value) {
-  case TessellationDomainOrigin::eUpperLeft:
-    return "UpperLeft";
-  case TessellationDomainOrigin::eLowerLeft:
-    return "LowerLeft";
+  case RasterizationOrderAMD::eStrict:
+    return "Strict";
+  case RasterizationOrderAMD::eRelaxed:
+    return "Relaxed";
   default:
     return "invalid ( " +
            VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
@@ -13150,6 +12262,892 @@
   }
 }
 
+//=== VK_AMD_shader_info ===
+
+enum class ShaderInfoTypeAMD {
+  eStatistics = VK_SHADER_INFO_TYPE_STATISTICS_AMD,
+  eBinary = VK_SHADER_INFO_TYPE_BINARY_AMD,
+  eDisassembly = VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD
+};
+
+VULKAN_HPP_INLINE std::string to_string(ShaderInfoTypeAMD value) {
+  switch (value) {
+  case ShaderInfoTypeAMD::eStatistics:
+    return "Statistics";
+  case ShaderInfoTypeAMD::eBinary:
+    return "Binary";
+  case ShaderInfoTypeAMD::eDisassembly:
+    return "Disassembly";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+//=== VK_NV_external_memory_capabilities ===
+
+enum class
+    ExternalMemoryHandleTypeFlagBitsNV : VkExternalMemoryHandleTypeFlagsNV {
+      eOpaqueWin32 = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV,
+      eOpaqueWin32Kmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV,
+      eD3D11Image = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV,
+      eD3D11ImageKmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV
+    };
+
+VULKAN_HPP_INLINE std::string
+to_string(ExternalMemoryHandleTypeFlagBitsNV value) {
+  switch (value) {
+  case ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32:
+    return "OpaqueWin32";
+  case ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32Kmt:
+    return "OpaqueWin32Kmt";
+  case ExternalMemoryHandleTypeFlagBitsNV::eD3D11Image:
+    return "D3D11Image";
+  case ExternalMemoryHandleTypeFlagBitsNV::eD3D11ImageKmt:
+    return "D3D11ImageKmt";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class ExternalMemoryFeatureFlagBitsNV : VkExternalMemoryFeatureFlagsNV {
+  eDedicatedOnly = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV,
+  eExportable = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV,
+  eImportable = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV
+};
+
+VULKAN_HPP_INLINE std::string to_string(ExternalMemoryFeatureFlagBitsNV value) {
+  switch (value) {
+  case ExternalMemoryFeatureFlagBitsNV::eDedicatedOnly:
+    return "DedicatedOnly";
+  case ExternalMemoryFeatureFlagBitsNV::eExportable:
+    return "Exportable";
+  case ExternalMemoryFeatureFlagBitsNV::eImportable:
+    return "Importable";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+//=== VK_EXT_validation_flags ===
+
+enum class ValidationCheckEXT {
+  eAll = VK_VALIDATION_CHECK_ALL_EXT,
+  eShaders = VK_VALIDATION_CHECK_SHADERS_EXT
+};
+
+VULKAN_HPP_INLINE std::string to_string(ValidationCheckEXT value) {
+  switch (value) {
+  case ValidationCheckEXT::eAll:
+    return "All";
+  case ValidationCheckEXT::eShaders:
+    return "Shaders";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+//=== VK_EXT_conditional_rendering ===
+
+enum class ConditionalRenderingFlagBitsEXT : VkConditionalRenderingFlagsEXT {
+  eInverted = VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT
+};
+
+VULKAN_HPP_INLINE std::string to_string(ConditionalRenderingFlagBitsEXT value) {
+  switch (value) {
+  case ConditionalRenderingFlagBitsEXT::eInverted:
+    return "Inverted";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+//=== VK_EXT_display_surface_counter ===
+
+enum class SurfaceCounterFlagBitsEXT : VkSurfaceCounterFlagsEXT {
+  eVblank = VK_SURFACE_COUNTER_VBLANK_BIT_EXT
+};
+
+VULKAN_HPP_INLINE std::string to_string(SurfaceCounterFlagBitsEXT value) {
+  switch (value) {
+  case SurfaceCounterFlagBitsEXT::eVblank:
+    return "Vblank";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+//=== VK_EXT_display_control ===
+
+enum class DisplayPowerStateEXT {
+  eOff = VK_DISPLAY_POWER_STATE_OFF_EXT,
+  eSuspend = VK_DISPLAY_POWER_STATE_SUSPEND_EXT,
+  eOn = VK_DISPLAY_POWER_STATE_ON_EXT
+};
+
+VULKAN_HPP_INLINE std::string to_string(DisplayPowerStateEXT value) {
+  switch (value) {
+  case DisplayPowerStateEXT::eOff:
+    return "Off";
+  case DisplayPowerStateEXT::eSuspend:
+    return "Suspend";
+  case DisplayPowerStateEXT::eOn:
+    return "On";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class DeviceEventTypeEXT {
+  eDisplayHotplug = VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT
+};
+
+VULKAN_HPP_INLINE std::string to_string(DeviceEventTypeEXT value) {
+  switch (value) {
+  case DeviceEventTypeEXT::eDisplayHotplug:
+    return "DisplayHotplug";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class DisplayEventTypeEXT {
+  eFirstPixelOut = VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT
+};
+
+VULKAN_HPP_INLINE std::string to_string(DisplayEventTypeEXT value) {
+  switch (value) {
+  case DisplayEventTypeEXT::eFirstPixelOut:
+    return "FirstPixelOut";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+//=== VK_NV_viewport_swizzle ===
+
+enum class ViewportCoordinateSwizzleNV {
+  ePositiveX = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV,
+  eNegativeX = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV,
+  ePositiveY = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV,
+  eNegativeY = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV,
+  ePositiveZ = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV,
+  eNegativeZ = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV,
+  ePositiveW = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV,
+  eNegativeW = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV
+};
+
+VULKAN_HPP_INLINE std::string to_string(ViewportCoordinateSwizzleNV value) {
+  switch (value) {
+  case ViewportCoordinateSwizzleNV::ePositiveX:
+    return "PositiveX";
+  case ViewportCoordinateSwizzleNV::eNegativeX:
+    return "NegativeX";
+  case ViewportCoordinateSwizzleNV::ePositiveY:
+    return "PositiveY";
+  case ViewportCoordinateSwizzleNV::eNegativeY:
+    return "NegativeY";
+  case ViewportCoordinateSwizzleNV::ePositiveZ:
+    return "PositiveZ";
+  case ViewportCoordinateSwizzleNV::eNegativeZ:
+    return "NegativeZ";
+  case ViewportCoordinateSwizzleNV::ePositiveW:
+    return "PositiveW";
+  case ViewportCoordinateSwizzleNV::eNegativeW:
+    return "NegativeW";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+//=== VK_EXT_discard_rectangles ===
+
+enum class DiscardRectangleModeEXT {
+  eInclusive = VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT,
+  eExclusive = VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT
+};
+
+VULKAN_HPP_INLINE std::string to_string(DiscardRectangleModeEXT value) {
+  switch (value) {
+  case DiscardRectangleModeEXT::eInclusive:
+    return "Inclusive";
+  case DiscardRectangleModeEXT::eExclusive:
+    return "Exclusive";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+//=== VK_EXT_conservative_rasterization ===
+
+enum class ConservativeRasterizationModeEXT {
+  eDisabled = VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT,
+  eOverestimate = VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT,
+  eUnderestimate = VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT
+};
+
+VULKAN_HPP_INLINE std::string
+to_string(ConservativeRasterizationModeEXT value) {
+  switch (value) {
+  case ConservativeRasterizationModeEXT::eDisabled:
+    return "Disabled";
+  case ConservativeRasterizationModeEXT::eOverestimate:
+    return "Overestimate";
+  case ConservativeRasterizationModeEXT::eUnderestimate:
+    return "Underestimate";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+//=== VK_KHR_performance_query ===
+
+enum class
+    PerformanceCounterDescriptionFlagBitsKHR : VkPerformanceCounterDescriptionFlagsKHR {
+      ePerformanceImpacting =
+          VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR,
+      eConcurrentlyImpacted =
+          VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR
+    };
+
+VULKAN_HPP_INLINE std::string
+to_string(PerformanceCounterDescriptionFlagBitsKHR value) {
+  switch (value) {
+  case PerformanceCounterDescriptionFlagBitsKHR::ePerformanceImpacting:
+    return "PerformanceImpacting";
+  case PerformanceCounterDescriptionFlagBitsKHR::eConcurrentlyImpacted:
+    return "ConcurrentlyImpacted";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class PerformanceCounterScopeKHR {
+  eCommandBuffer = VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR,
+  eRenderPass = VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR,
+  eCommand = VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR,
+  eVkQueryScopeCommandBuffer = VK_QUERY_SCOPE_COMMAND_BUFFER_KHR,
+  eVkQueryScopeCommand = VK_QUERY_SCOPE_COMMAND_KHR,
+  eVkQueryScopeRenderPass = VK_QUERY_SCOPE_RENDER_PASS_KHR
+};
+
+VULKAN_HPP_INLINE std::string to_string(PerformanceCounterScopeKHR value) {
+  switch (value) {
+  case PerformanceCounterScopeKHR::eCommandBuffer:
+    return "CommandBuffer";
+  case PerformanceCounterScopeKHR::eRenderPass:
+    return "RenderPass";
+  case PerformanceCounterScopeKHR::eCommand:
+    return "Command";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class PerformanceCounterStorageKHR {
+  eInt32 = VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR,
+  eInt64 = VK_PERFORMANCE_COUNTER_STORAGE_INT64_KHR,
+  eUint32 = VK_PERFORMANCE_COUNTER_STORAGE_UINT32_KHR,
+  eUint64 = VK_PERFORMANCE_COUNTER_STORAGE_UINT64_KHR,
+  eFloat32 = VK_PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR,
+  eFloat64 = VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR
+};
+
+VULKAN_HPP_INLINE std::string to_string(PerformanceCounterStorageKHR value) {
+  switch (value) {
+  case PerformanceCounterStorageKHR::eInt32:
+    return "Int32";
+  case PerformanceCounterStorageKHR::eInt64:
+    return "Int64";
+  case PerformanceCounterStorageKHR::eUint32:
+    return "Uint32";
+  case PerformanceCounterStorageKHR::eUint64:
+    return "Uint64";
+  case PerformanceCounterStorageKHR::eFloat32:
+    return "Float32";
+  case PerformanceCounterStorageKHR::eFloat64:
+    return "Float64";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class PerformanceCounterUnitKHR {
+  eGeneric = VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR,
+  ePercentage = VK_PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR,
+  eNanoseconds = VK_PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR,
+  eBytes = VK_PERFORMANCE_COUNTER_UNIT_BYTES_KHR,
+  eBytesPerSecond = VK_PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR,
+  eKelvin = VK_PERFORMANCE_COUNTER_UNIT_KELVIN_KHR,
+  eWatts = VK_PERFORMANCE_COUNTER_UNIT_WATTS_KHR,
+  eVolts = VK_PERFORMANCE_COUNTER_UNIT_VOLTS_KHR,
+  eAmps = VK_PERFORMANCE_COUNTER_UNIT_AMPS_KHR,
+  eHertz = VK_PERFORMANCE_COUNTER_UNIT_HERTZ_KHR,
+  eCycles = VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR
+};
+
+VULKAN_HPP_INLINE std::string to_string(PerformanceCounterUnitKHR value) {
+  switch (value) {
+  case PerformanceCounterUnitKHR::eGeneric:
+    return "Generic";
+  case PerformanceCounterUnitKHR::ePercentage:
+    return "Percentage";
+  case PerformanceCounterUnitKHR::eNanoseconds:
+    return "Nanoseconds";
+  case PerformanceCounterUnitKHR::eBytes:
+    return "Bytes";
+  case PerformanceCounterUnitKHR::eBytesPerSecond:
+    return "BytesPerSecond";
+  case PerformanceCounterUnitKHR::eKelvin:
+    return "Kelvin";
+  case PerformanceCounterUnitKHR::eWatts:
+    return "Watts";
+  case PerformanceCounterUnitKHR::eVolts:
+    return "Volts";
+  case PerformanceCounterUnitKHR::eAmps:
+    return "Amps";
+  case PerformanceCounterUnitKHR::eHertz:
+    return "Hertz";
+  case PerformanceCounterUnitKHR::eCycles:
+    return "Cycles";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class AcquireProfilingLockFlagBitsKHR : VkAcquireProfilingLockFlagsKHR {};
+
+VULKAN_HPP_INLINE std::string to_string(AcquireProfilingLockFlagBitsKHR) {
+  return "(void)";
+}
+
+//=== VK_EXT_debug_utils ===
+
+enum class
+    DebugUtilsMessageSeverityFlagBitsEXT : VkDebugUtilsMessageSeverityFlagsEXT {
+      eVerbose = VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT,
+      eInfo = VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT,
+      eWarning = VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT,
+      eError = VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT
+    };
+
+VULKAN_HPP_INLINE std::string
+to_string(DebugUtilsMessageSeverityFlagBitsEXT value) {
+  switch (value) {
+  case DebugUtilsMessageSeverityFlagBitsEXT::eVerbose:
+    return "Verbose";
+  case DebugUtilsMessageSeverityFlagBitsEXT::eInfo:
+    return "Info";
+  case DebugUtilsMessageSeverityFlagBitsEXT::eWarning:
+    return "Warning";
+  case DebugUtilsMessageSeverityFlagBitsEXT::eError:
+    return "Error";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class DebugUtilsMessageTypeFlagBitsEXT : VkDebugUtilsMessageTypeFlagsEXT {
+  eGeneral = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT,
+  eValidation = VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT,
+  ePerformance = VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT
+};
+
+VULKAN_HPP_INLINE std::string
+to_string(DebugUtilsMessageTypeFlagBitsEXT value) {
+  switch (value) {
+  case DebugUtilsMessageTypeFlagBitsEXT::eGeneral:
+    return "General";
+  case DebugUtilsMessageTypeFlagBitsEXT::eValidation:
+    return "Validation";
+  case DebugUtilsMessageTypeFlagBitsEXT::ePerformance:
+    return "Performance";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+//=== VK_EXT_blend_operation_advanced ===
+
+enum class BlendOverlapEXT {
+  eUncorrelated = VK_BLEND_OVERLAP_UNCORRELATED_EXT,
+  eDisjoint = VK_BLEND_OVERLAP_DISJOINT_EXT,
+  eConjoint = VK_BLEND_OVERLAP_CONJOINT_EXT
+};
+
+VULKAN_HPP_INLINE std::string to_string(BlendOverlapEXT value) {
+  switch (value) {
+  case BlendOverlapEXT::eUncorrelated:
+    return "Uncorrelated";
+  case BlendOverlapEXT::eDisjoint:
+    return "Disjoint";
+  case BlendOverlapEXT::eConjoint:
+    return "Conjoint";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+//=== VK_KHR_acceleration_structure ===
+
+enum class AccelerationStructureTypeKHR {
+  eTopLevel = VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR,
+  eBottomLevel = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR,
+  eGeneric = VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR
+};
+using AccelerationStructureTypeNV = AccelerationStructureTypeKHR;
+
+VULKAN_HPP_INLINE std::string to_string(AccelerationStructureTypeKHR value) {
+  switch (value) {
+  case AccelerationStructureTypeKHR::eTopLevel:
+    return "TopLevel";
+  case AccelerationStructureTypeKHR::eBottomLevel:
+    return "BottomLevel";
+  case AccelerationStructureTypeKHR::eGeneric:
+    return "Generic";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class AccelerationStructureBuildTypeKHR {
+  eHost = VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_KHR,
+  eDevice = VK_ACCELERATION_STRUCTURE_BUILD_TYPE_DEVICE_KHR,
+  eHostOrDevice = VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_OR_DEVICE_KHR
+};
+
+VULKAN_HPP_INLINE std::string
+to_string(AccelerationStructureBuildTypeKHR value) {
+  switch (value) {
+  case AccelerationStructureBuildTypeKHR::eHost:
+    return "Host";
+  case AccelerationStructureBuildTypeKHR::eDevice:
+    return "Device";
+  case AccelerationStructureBuildTypeKHR::eHostOrDevice:
+    return "HostOrDevice";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class GeometryFlagBitsKHR : VkGeometryFlagsKHR {
+  eOpaque = VK_GEOMETRY_OPAQUE_BIT_KHR,
+  eNoDuplicateAnyHitInvocation =
+      VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR
+};
+using GeometryFlagBitsNV = GeometryFlagBitsKHR;
+
+VULKAN_HPP_INLINE std::string to_string(GeometryFlagBitsKHR value) {
+  switch (value) {
+  case GeometryFlagBitsKHR::eOpaque:
+    return "Opaque";
+  case GeometryFlagBitsKHR::eNoDuplicateAnyHitInvocation:
+    return "NoDuplicateAnyHitInvocation";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class GeometryInstanceFlagBitsKHR : VkGeometryInstanceFlagsKHR {
+  eTriangleFacingCullDisable =
+      VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR,
+  eTriangleFrontCounterclockwise =
+      VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR,
+  eForceOpaque = VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR,
+  eForceNoOpaque = VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR,
+  eTriangleCullDisable = VK_GEOMETRY_INSTANCE_TRIANGLE_CULL_DISABLE_BIT_NV
+};
+using GeometryInstanceFlagBitsNV = GeometryInstanceFlagBitsKHR;
+
+VULKAN_HPP_INLINE std::string to_string(GeometryInstanceFlagBitsKHR value) {
+  switch (value) {
+  case GeometryInstanceFlagBitsKHR::eTriangleFacingCullDisable:
+    return "TriangleFacingCullDisable";
+  case GeometryInstanceFlagBitsKHR::eTriangleFrontCounterclockwise:
+    return "TriangleFrontCounterclockwise";
+  case GeometryInstanceFlagBitsKHR::eForceOpaque:
+    return "ForceOpaque";
+  case GeometryInstanceFlagBitsKHR::eForceNoOpaque:
+    return "ForceNoOpaque";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class
+    BuildAccelerationStructureFlagBitsKHR : VkBuildAccelerationStructureFlagsKHR {
+      eAllowUpdate = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR,
+      eAllowCompaction =
+          VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR,
+      ePreferFastTrace =
+          VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR,
+      ePreferFastBuild =
+          VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR,
+      eLowMemory = VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR
+    };
+using BuildAccelerationStructureFlagBitsNV =
+    BuildAccelerationStructureFlagBitsKHR;
+
+VULKAN_HPP_INLINE std::string
+to_string(BuildAccelerationStructureFlagBitsKHR value) {
+  switch (value) {
+  case BuildAccelerationStructureFlagBitsKHR::eAllowUpdate:
+    return "AllowUpdate";
+  case BuildAccelerationStructureFlagBitsKHR::eAllowCompaction:
+    return "AllowCompaction";
+  case BuildAccelerationStructureFlagBitsKHR::ePreferFastTrace:
+    return "PreferFastTrace";
+  case BuildAccelerationStructureFlagBitsKHR::ePreferFastBuild:
+    return "PreferFastBuild";
+  case BuildAccelerationStructureFlagBitsKHR::eLowMemory:
+    return "LowMemory";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class CopyAccelerationStructureModeKHR {
+  eClone = VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR,
+  eCompact = VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR,
+  eSerialize = VK_COPY_ACCELERATION_STRUCTURE_MODE_SERIALIZE_KHR,
+  eDeserialize = VK_COPY_ACCELERATION_STRUCTURE_MODE_DESERIALIZE_KHR
+};
+using CopyAccelerationStructureModeNV = CopyAccelerationStructureModeKHR;
+
+VULKAN_HPP_INLINE std::string
+to_string(CopyAccelerationStructureModeKHR value) {
+  switch (value) {
+  case CopyAccelerationStructureModeKHR::eClone:
+    return "Clone";
+  case CopyAccelerationStructureModeKHR::eCompact:
+    return "Compact";
+  case CopyAccelerationStructureModeKHR::eSerialize:
+    return "Serialize";
+  case CopyAccelerationStructureModeKHR::eDeserialize:
+    return "Deserialize";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class GeometryTypeKHR {
+  eTriangles = VK_GEOMETRY_TYPE_TRIANGLES_KHR,
+  eAabbs = VK_GEOMETRY_TYPE_AABBS_KHR,
+  eInstances = VK_GEOMETRY_TYPE_INSTANCES_KHR
+};
+using GeometryTypeNV = GeometryTypeKHR;
+
+VULKAN_HPP_INLINE std::string to_string(GeometryTypeKHR value) {
+  switch (value) {
+  case GeometryTypeKHR::eTriangles:
+    return "Triangles";
+  case GeometryTypeKHR::eAabbs:
+    return "Aabbs";
+  case GeometryTypeKHR::eInstances:
+    return "Instances";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class AccelerationStructureCompatibilityKHR {
+  eCompatible = VK_ACCELERATION_STRUCTURE_COMPATIBILITY_COMPATIBLE_KHR,
+  eIncompatible = VK_ACCELERATION_STRUCTURE_COMPATIBILITY_INCOMPATIBLE_KHR
+};
+
+VULKAN_HPP_INLINE std::string
+to_string(AccelerationStructureCompatibilityKHR value) {
+  switch (value) {
+  case AccelerationStructureCompatibilityKHR::eCompatible:
+    return "Compatible";
+  case AccelerationStructureCompatibilityKHR::eIncompatible:
+    return "Incompatible";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class
+    AccelerationStructureCreateFlagBitsKHR : VkAccelerationStructureCreateFlagsKHR {
+      eDeviceAddressCaptureReplay =
+          VK_ACCELERATION_STRUCTURE_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR
+    };
+
+VULKAN_HPP_INLINE std::string
+to_string(AccelerationStructureCreateFlagBitsKHR value) {
+  switch (value) {
+  case AccelerationStructureCreateFlagBitsKHR::eDeviceAddressCaptureReplay:
+    return "DeviceAddressCaptureReplay";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class BuildAccelerationStructureModeKHR {
+  eBuild = VK_BUILD_ACCELERATION_STRUCTURE_MODE_BUILD_KHR,
+  eUpdate = VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR
+};
+
+VULKAN_HPP_INLINE std::string
+to_string(BuildAccelerationStructureModeKHR value) {
+  switch (value) {
+  case BuildAccelerationStructureModeKHR::eBuild:
+    return "Build";
+  case BuildAccelerationStructureModeKHR::eUpdate:
+    return "Update";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+//=== VK_NV_framebuffer_mixed_samples ===
+
+enum class CoverageModulationModeNV {
+  eNone = VK_COVERAGE_MODULATION_MODE_NONE_NV,
+  eRgb = VK_COVERAGE_MODULATION_MODE_RGB_NV,
+  eAlpha = VK_COVERAGE_MODULATION_MODE_ALPHA_NV,
+  eRgba = VK_COVERAGE_MODULATION_MODE_RGBA_NV
+};
+
+VULKAN_HPP_INLINE std::string to_string(CoverageModulationModeNV value) {
+  switch (value) {
+  case CoverageModulationModeNV::eNone:
+    return "None";
+  case CoverageModulationModeNV::eRgb:
+    return "Rgb";
+  case CoverageModulationModeNV::eAlpha:
+    return "Alpha";
+  case CoverageModulationModeNV::eRgba:
+    return "Rgba";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+//=== VK_EXT_validation_cache ===
+
+enum class ValidationCacheHeaderVersionEXT {
+  eOne = VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT
+};
+
+VULKAN_HPP_INLINE std::string to_string(ValidationCacheHeaderVersionEXT value) {
+  switch (value) {
+  case ValidationCacheHeaderVersionEXT::eOne:
+    return "One";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+//=== VK_NV_shading_rate_image ===
+
+enum class ShadingRatePaletteEntryNV {
+  eNoInvocations = VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV,
+  e16InvocationsPerPixel =
+      VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV,
+  e8InvocationsPerPixel =
+      VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV,
+  e4InvocationsPerPixel =
+      VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV,
+  e2InvocationsPerPixel =
+      VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV,
+  e1InvocationPerPixel =
+      VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV,
+  e1InvocationPer2X1Pixels =
+      VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV,
+  e1InvocationPer1X2Pixels =
+      VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV,
+  e1InvocationPer2X2Pixels =
+      VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV,
+  e1InvocationPer4X2Pixels =
+      VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV,
+  e1InvocationPer2X4Pixels =
+      VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV,
+  e1InvocationPer4X4Pixels =
+      VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV
+};
+
+VULKAN_HPP_INLINE std::string to_string(ShadingRatePaletteEntryNV value) {
+  switch (value) {
+  case ShadingRatePaletteEntryNV::eNoInvocations:
+    return "NoInvocations";
+  case ShadingRatePaletteEntryNV::e16InvocationsPerPixel:
+    return "16InvocationsPerPixel";
+  case ShadingRatePaletteEntryNV::e8InvocationsPerPixel:
+    return "8InvocationsPerPixel";
+  case ShadingRatePaletteEntryNV::e4InvocationsPerPixel:
+    return "4InvocationsPerPixel";
+  case ShadingRatePaletteEntryNV::e2InvocationsPerPixel:
+    return "2InvocationsPerPixel";
+  case ShadingRatePaletteEntryNV::e1InvocationPerPixel:
+    return "1InvocationPerPixel";
+  case ShadingRatePaletteEntryNV::e1InvocationPer2X1Pixels:
+    return "1InvocationPer2X1Pixels";
+  case ShadingRatePaletteEntryNV::e1InvocationPer1X2Pixels:
+    return "1InvocationPer1X2Pixels";
+  case ShadingRatePaletteEntryNV::e1InvocationPer2X2Pixels:
+    return "1InvocationPer2X2Pixels";
+  case ShadingRatePaletteEntryNV::e1InvocationPer4X2Pixels:
+    return "1InvocationPer4X2Pixels";
+  case ShadingRatePaletteEntryNV::e1InvocationPer2X4Pixels:
+    return "1InvocationPer2X4Pixels";
+  case ShadingRatePaletteEntryNV::e1InvocationPer4X4Pixels:
+    return "1InvocationPer4X4Pixels";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class CoarseSampleOrderTypeNV {
+  eDefault = VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV,
+  eCustom = VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV,
+  ePixelMajor = VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV,
+  eSampleMajor = VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV
+};
+
+VULKAN_HPP_INLINE std::string to_string(CoarseSampleOrderTypeNV value) {
+  switch (value) {
+  case CoarseSampleOrderTypeNV::eDefault:
+    return "Default";
+  case CoarseSampleOrderTypeNV::eCustom:
+    return "Custom";
+  case CoarseSampleOrderTypeNV::ePixelMajor:
+    return "PixelMajor";
+  case CoarseSampleOrderTypeNV::eSampleMajor:
+    return "SampleMajor";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+//=== VK_NV_ray_tracing ===
+
+enum class AccelerationStructureMemoryRequirementsTypeNV {
+  eObject = VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV,
+  eBuildScratch =
+      VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_NV,
+  eUpdateScratch =
+      VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV
+};
+
+VULKAN_HPP_INLINE std::string
+to_string(AccelerationStructureMemoryRequirementsTypeNV value) {
+  switch (value) {
+  case AccelerationStructureMemoryRequirementsTypeNV::eObject:
+    return "Object";
+  case AccelerationStructureMemoryRequirementsTypeNV::eBuildScratch:
+    return "BuildScratch";
+  case AccelerationStructureMemoryRequirementsTypeNV::eUpdateScratch:
+    return "UpdateScratch";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+//=== VK_EXT_global_priority ===
+
+enum class QueueGlobalPriorityEXT {
+  eLow = VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT,
+  eMedium = VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT,
+  eHigh = VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT,
+  eRealtime = VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT
+};
+
+VULKAN_HPP_INLINE std::string to_string(QueueGlobalPriorityEXT value) {
+  switch (value) {
+  case QueueGlobalPriorityEXT::eLow:
+    return "Low";
+  case QueueGlobalPriorityEXT::eMedium:
+    return "Medium";
+  case QueueGlobalPriorityEXT::eHigh:
+    return "High";
+  case QueueGlobalPriorityEXT::eRealtime:
+    return "Realtime";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+//=== VK_AMD_pipeline_compiler_control ===
+
+enum class
+    PipelineCompilerControlFlagBitsAMD : VkPipelineCompilerControlFlagsAMD {};
+
+VULKAN_HPP_INLINE std::string to_string(PipelineCompilerControlFlagBitsAMD) {
+  return "(void)";
+}
+
+//=== VK_EXT_calibrated_timestamps ===
+
 enum class TimeDomainEXT {
   eDevice = VK_TIME_DOMAIN_DEVICE_EXT,
   eClockMonotonic = VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT,
@@ -13174,6 +13172,196 @@
   }
 }
 
+//=== VK_AMD_memory_overallocation_behavior ===
+
+enum class MemoryOverallocationBehaviorAMD {
+  eDefault = VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD,
+  eAllowed = VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD,
+  eDisallowed = VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD
+};
+
+VULKAN_HPP_INLINE std::string to_string(MemoryOverallocationBehaviorAMD value) {
+  switch (value) {
+  case MemoryOverallocationBehaviorAMD::eDefault:
+    return "Default";
+  case MemoryOverallocationBehaviorAMD::eAllowed:
+    return "Allowed";
+  case MemoryOverallocationBehaviorAMD::eDisallowed:
+    return "Disallowed";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+//=== VK_EXT_pipeline_creation_feedback ===
+
+enum class
+    PipelineCreationFeedbackFlagBitsEXT : VkPipelineCreationFeedbackFlagsEXT {
+      eValid = VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT_EXT,
+      eApplicationPipelineCacheHit =
+          VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT_EXT,
+      eBasePipelineAcceleration =
+          VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT_EXT
+    };
+
+VULKAN_HPP_INLINE std::string
+to_string(PipelineCreationFeedbackFlagBitsEXT value) {
+  switch (value) {
+  case PipelineCreationFeedbackFlagBitsEXT::eValid:
+    return "Valid";
+  case PipelineCreationFeedbackFlagBitsEXT::eApplicationPipelineCacheHit:
+    return "ApplicationPipelineCacheHit";
+  case PipelineCreationFeedbackFlagBitsEXT::eBasePipelineAcceleration:
+    return "BasePipelineAcceleration";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+//=== VK_INTEL_performance_query ===
+
+enum class PerformanceConfigurationTypeINTEL {
+  eCommandQueueMetricsDiscoveryActivated =
+      VK_PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL
+};
+
+VULKAN_HPP_INLINE std::string
+to_string(PerformanceConfigurationTypeINTEL value) {
+  switch (value) {
+  case PerformanceConfigurationTypeINTEL::
+      eCommandQueueMetricsDiscoveryActivated:
+    return "CommandQueueMetricsDiscoveryActivated";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class QueryPoolSamplingModeINTEL {
+  eManual = VK_QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL
+};
+
+VULKAN_HPP_INLINE std::string to_string(QueryPoolSamplingModeINTEL value) {
+  switch (value) {
+  case QueryPoolSamplingModeINTEL::eManual:
+    return "Manual";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class PerformanceOverrideTypeINTEL {
+  eNullHardware = VK_PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL,
+  eFlushGpuCaches = VK_PERFORMANCE_OVERRIDE_TYPE_FLUSH_GPU_CACHES_INTEL
+};
+
+VULKAN_HPP_INLINE std::string to_string(PerformanceOverrideTypeINTEL value) {
+  switch (value) {
+  case PerformanceOverrideTypeINTEL::eNullHardware:
+    return "NullHardware";
+  case PerformanceOverrideTypeINTEL::eFlushGpuCaches:
+    return "FlushGpuCaches";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class PerformanceParameterTypeINTEL {
+  eHwCountersSupported =
+      VK_PERFORMANCE_PARAMETER_TYPE_HW_COUNTERS_SUPPORTED_INTEL,
+  eStreamMarkerValidBits =
+      VK_PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL
+};
+
+VULKAN_HPP_INLINE std::string to_string(PerformanceParameterTypeINTEL value) {
+  switch (value) {
+  case PerformanceParameterTypeINTEL::eHwCountersSupported:
+    return "HwCountersSupported";
+  case PerformanceParameterTypeINTEL::eStreamMarkerValidBits:
+    return "StreamMarkerValidBits";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class PerformanceValueTypeINTEL {
+  eUint32 = VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL,
+  eUint64 = VK_PERFORMANCE_VALUE_TYPE_UINT64_INTEL,
+  eFloat = VK_PERFORMANCE_VALUE_TYPE_FLOAT_INTEL,
+  eBool = VK_PERFORMANCE_VALUE_TYPE_BOOL_INTEL,
+  eString = VK_PERFORMANCE_VALUE_TYPE_STRING_INTEL
+};
+
+VULKAN_HPP_INLINE std::string to_string(PerformanceValueTypeINTEL value) {
+  switch (value) {
+  case PerformanceValueTypeINTEL::eUint32:
+    return "Uint32";
+  case PerformanceValueTypeINTEL::eUint64:
+    return "Uint64";
+  case PerformanceValueTypeINTEL::eFloat:
+    return "Float";
+  case PerformanceValueTypeINTEL::eBool:
+    return "Bool";
+  case PerformanceValueTypeINTEL::eString:
+    return "String";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+//=== VK_KHR_fragment_shading_rate ===
+
+enum class FragmentShadingRateCombinerOpKHR {
+  eKeep = VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR,
+  eReplace = VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR,
+  eMin = VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_KHR,
+  eMax = VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_KHR,
+  eMul = VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR
+};
+
+VULKAN_HPP_INLINE std::string
+to_string(FragmentShadingRateCombinerOpKHR value) {
+  switch (value) {
+  case FragmentShadingRateCombinerOpKHR::eKeep:
+    return "Keep";
+  case FragmentShadingRateCombinerOpKHR::eReplace:
+    return "Replace";
+  case FragmentShadingRateCombinerOpKHR::eMin:
+    return "Min";
+  case FragmentShadingRateCombinerOpKHR::eMax:
+    return "Max";
+  case FragmentShadingRateCombinerOpKHR::eMul:
+    return "Mul";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+//=== VK_AMD_shader_core_properties2 ===
+
+enum class ShaderCorePropertiesFlagBitsAMD : VkShaderCorePropertiesFlagsAMD {};
+
+VULKAN_HPP_INLINE std::string to_string(ShaderCorePropertiesFlagBitsAMD) {
+  return "(void)";
+}
+
+//=== VK_EXT_tooling_info ===
+
 enum class ToolPurposeFlagBitsEXT : VkToolPurposeFlagsEXT {
   eValidation = VK_TOOL_PURPOSE_VALIDATION_BIT_EXT,
   eProfiling = VK_TOOL_PURPOSE_PROFILING_BIT_EXT,
@@ -13207,32 +13395,30 @@
   }
 }
 
-enum class ValidationCacheHeaderVersionEXT {
-  eOne = VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT
+//=== VK_EXT_validation_features ===
+
+enum class ValidationFeatureEnableEXT {
+  eGpuAssisted = VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT,
+  eGpuAssistedReserveBindingSlot =
+      VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT,
+  eBestPractices = VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT,
+  eDebugPrintf = VK_VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT,
+  eSynchronizationValidation =
+      VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT
 };
 
-VULKAN_HPP_INLINE std::string to_string(ValidationCacheHeaderVersionEXT value) {
+VULKAN_HPP_INLINE std::string to_string(ValidationFeatureEnableEXT value) {
   switch (value) {
-  case ValidationCacheHeaderVersionEXT::eOne:
-    return "One";
-  default:
-    return "invalid ( " +
-           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
-           " )";
-  }
-}
-
-enum class ValidationCheckEXT {
-  eAll = VK_VALIDATION_CHECK_ALL_EXT,
-  eShaders = VK_VALIDATION_CHECK_SHADERS_EXT
-};
-
-VULKAN_HPP_INLINE std::string to_string(ValidationCheckEXT value) {
-  switch (value) {
-  case ValidationCheckEXT::eAll:
-    return "All";
-  case ValidationCheckEXT::eShaders:
-    return "Shaders";
+  case ValidationFeatureEnableEXT::eGpuAssisted:
+    return "GpuAssisted";
+  case ValidationFeatureEnableEXT::eGpuAssistedReserveBindingSlot:
+    return "GpuAssistedReserveBindingSlot";
+  case ValidationFeatureEnableEXT::eBestPractices:
+    return "BestPractices";
+  case ValidationFeatureEnableEXT::eDebugPrintf:
+    return "DebugPrintf";
+  case ValidationFeatureEnableEXT::eSynchronizationValidation:
+    return "SynchronizationValidation";
   default:
     return "invalid ( " +
            VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
@@ -13273,28 +13459,25 @@
   }
 }
 
-enum class ValidationFeatureEnableEXT {
-  eGpuAssisted = VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT,
-  eGpuAssistedReserveBindingSlot =
-      VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT,
-  eBestPractices = VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT,
-  eDebugPrintf = VK_VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT,
-  eSynchronizationValidation =
-      VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT
+//=== VK_NV_cooperative_matrix ===
+
+enum class ScopeNV {
+  eDevice = VK_SCOPE_DEVICE_NV,
+  eWorkgroup = VK_SCOPE_WORKGROUP_NV,
+  eSubgroup = VK_SCOPE_SUBGROUP_NV,
+  eQueueFamily = VK_SCOPE_QUEUE_FAMILY_NV
 };
 
-VULKAN_HPP_INLINE std::string to_string(ValidationFeatureEnableEXT value) {
+VULKAN_HPP_INLINE std::string to_string(ScopeNV value) {
   switch (value) {
-  case ValidationFeatureEnableEXT::eGpuAssisted:
-    return "GpuAssisted";
-  case ValidationFeatureEnableEXT::eGpuAssistedReserveBindingSlot:
-    return "GpuAssistedReserveBindingSlot";
-  case ValidationFeatureEnableEXT::eBestPractices:
-    return "BestPractices";
-  case ValidationFeatureEnableEXT::eDebugPrintf:
-    return "DebugPrintf";
-  case ValidationFeatureEnableEXT::eSynchronizationValidation:
-    return "SynchronizationValidation";
+  case ScopeNV::eDevice:
+    return "Device";
+  case ScopeNV::eWorkgroup:
+    return "Workgroup";
+  case ScopeNV::eSubgroup:
+    return "Subgroup";
+  case ScopeNV::eQueueFamily:
+    return "QueueFamily";
   default:
     return "invalid ( " +
            VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
@@ -13302,29 +13485,44 @@
   }
 }
 
-enum class VendorId {
-  eVIV = VK_VENDOR_ID_VIV,
-  eVSI = VK_VENDOR_ID_VSI,
-  eKazan = VK_VENDOR_ID_KAZAN,
-  eCodeplay = VK_VENDOR_ID_CODEPLAY,
-  eMESA = VK_VENDOR_ID_MESA,
-  ePocl = VK_VENDOR_ID_POCL
+enum class ComponentTypeNV {
+  eFloat16 = VK_COMPONENT_TYPE_FLOAT16_NV,
+  eFloat32 = VK_COMPONENT_TYPE_FLOAT32_NV,
+  eFloat64 = VK_COMPONENT_TYPE_FLOAT64_NV,
+  eSint8 = VK_COMPONENT_TYPE_SINT8_NV,
+  eSint16 = VK_COMPONENT_TYPE_SINT16_NV,
+  eSint32 = VK_COMPONENT_TYPE_SINT32_NV,
+  eSint64 = VK_COMPONENT_TYPE_SINT64_NV,
+  eUint8 = VK_COMPONENT_TYPE_UINT8_NV,
+  eUint16 = VK_COMPONENT_TYPE_UINT16_NV,
+  eUint32 = VK_COMPONENT_TYPE_UINT32_NV,
+  eUint64 = VK_COMPONENT_TYPE_UINT64_NV
 };
 
-VULKAN_HPP_INLINE std::string to_string(VendorId value) {
+VULKAN_HPP_INLINE std::string to_string(ComponentTypeNV value) {
   switch (value) {
-  case VendorId::eVIV:
-    return "VIV";
-  case VendorId::eVSI:
-    return "VSI";
-  case VendorId::eKazan:
-    return "Kazan";
-  case VendorId::eCodeplay:
-    return "Codeplay";
-  case VendorId::eMESA:
-    return "MESA";
-  case VendorId::ePocl:
-    return "Pocl";
+  case ComponentTypeNV::eFloat16:
+    return "Float16";
+  case ComponentTypeNV::eFloat32:
+    return "Float32";
+  case ComponentTypeNV::eFloat64:
+    return "Float64";
+  case ComponentTypeNV::eSint8:
+    return "Sint8";
+  case ComponentTypeNV::eSint16:
+    return "Sint16";
+  case ComponentTypeNV::eSint32:
+    return "Sint32";
+  case ComponentTypeNV::eSint64:
+    return "Sint64";
+  case ComponentTypeNV::eUint8:
+    return "Uint8";
+  case ComponentTypeNV::eUint16:
+    return "Uint16";
+  case ComponentTypeNV::eUint32:
+    return "Uint32";
+  case ComponentTypeNV::eUint64:
+    return "Uint64";
   default:
     return "invalid ( " +
            VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
@@ -13332,17 +13530,19 @@
   }
 }
 
-enum class VertexInputRate {
-  eVertex = VK_VERTEX_INPUT_RATE_VERTEX,
-  eInstance = VK_VERTEX_INPUT_RATE_INSTANCE
+//=== VK_NV_coverage_reduction_mode ===
+
+enum class CoverageReductionModeNV {
+  eMerge = VK_COVERAGE_REDUCTION_MODE_MERGE_NV,
+  eTruncate = VK_COVERAGE_REDUCTION_MODE_TRUNCATE_NV
 };
 
-VULKAN_HPP_INLINE std::string to_string(VertexInputRate value) {
+VULKAN_HPP_INLINE std::string to_string(CoverageReductionModeNV value) {
   switch (value) {
-  case VertexInputRate::eVertex:
-    return "Vertex";
-  case VertexInputRate::eInstance:
-    return "Instance";
+  case CoverageReductionModeNV::eMerge:
+    return "Merge";
+  case CoverageReductionModeNV::eTruncate:
+    return "Truncate";
   default:
     return "invalid ( " +
            VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
@@ -13350,41 +13550,748 @@
   }
 }
 
-enum class ViewportCoordinateSwizzleNV {
-  ePositiveX = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV,
-  eNegativeX = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV,
-  ePositiveY = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV,
-  eNegativeY = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV,
-  ePositiveZ = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV,
-  eNegativeZ = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV,
-  ePositiveW = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV,
-  eNegativeW = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV
+#if defined(VK_USE_PLATFORM_WIN32_KHR)
+
+//=== VK_EXT_full_screen_exclusive ===
+
+enum class FullScreenExclusiveEXT {
+  eDefault = VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT,
+  eAllowed = VK_FULL_SCREEN_EXCLUSIVE_ALLOWED_EXT,
+  eDisallowed = VK_FULL_SCREEN_EXCLUSIVE_DISALLOWED_EXT,
+  eApplicationControlled = VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT
 };
 
-VULKAN_HPP_INLINE std::string to_string(ViewportCoordinateSwizzleNV value) {
+VULKAN_HPP_INLINE std::string to_string(FullScreenExclusiveEXT value) {
   switch (value) {
-  case ViewportCoordinateSwizzleNV::ePositiveX:
-    return "PositiveX";
-  case ViewportCoordinateSwizzleNV::eNegativeX:
-    return "NegativeX";
-  case ViewportCoordinateSwizzleNV::ePositiveY:
-    return "PositiveY";
-  case ViewportCoordinateSwizzleNV::eNegativeY:
-    return "NegativeY";
-  case ViewportCoordinateSwizzleNV::ePositiveZ:
-    return "PositiveZ";
-  case ViewportCoordinateSwizzleNV::eNegativeZ:
-    return "NegativeZ";
-  case ViewportCoordinateSwizzleNV::ePositiveW:
-    return "PositiveW";
-  case ViewportCoordinateSwizzleNV::eNegativeW:
-    return "NegativeW";
+  case FullScreenExclusiveEXT::eDefault:
+    return "Default";
+  case FullScreenExclusiveEXT::eAllowed:
+    return "Allowed";
+  case FullScreenExclusiveEXT::eDisallowed:
+    return "Disallowed";
+  case FullScreenExclusiveEXT::eApplicationControlled:
+    return "ApplicationControlled";
   default:
     return "invalid ( " +
            VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
            " )";
   }
 }
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+//=== VK_EXT_line_rasterization ===
+
+enum class LineRasterizationModeEXT {
+  eDefault = VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT,
+  eRectangular = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT,
+  eBresenham = VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT,
+  eRectangularSmooth = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT
+};
+
+VULKAN_HPP_INLINE std::string to_string(LineRasterizationModeEXT value) {
+  switch (value) {
+  case LineRasterizationModeEXT::eDefault:
+    return "Default";
+  case LineRasterizationModeEXT::eRectangular:
+    return "Rectangular";
+  case LineRasterizationModeEXT::eBresenham:
+    return "Bresenham";
+  case LineRasterizationModeEXT::eRectangularSmooth:
+    return "RectangularSmooth";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+//=== VK_KHR_pipeline_executable_properties ===
+
+enum class PipelineExecutableStatisticFormatKHR {
+  eBool32 = VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR,
+  eInt64 = VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR,
+  eUint64 = VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR,
+  eFloat64 = VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR
+};
+
+VULKAN_HPP_INLINE std::string
+to_string(PipelineExecutableStatisticFormatKHR value) {
+  switch (value) {
+  case PipelineExecutableStatisticFormatKHR::eBool32:
+    return "Bool32";
+  case PipelineExecutableStatisticFormatKHR::eInt64:
+    return "Int64";
+  case PipelineExecutableStatisticFormatKHR::eUint64:
+    return "Uint64";
+  case PipelineExecutableStatisticFormatKHR::eFloat64:
+    return "Float64";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+//=== VK_NV_device_generated_commands ===
+
+enum class IndirectStateFlagBitsNV : VkIndirectStateFlagsNV {
+  eFlagFrontface = VK_INDIRECT_STATE_FLAG_FRONTFACE_BIT_NV
+};
+
+VULKAN_HPP_INLINE std::string to_string(IndirectStateFlagBitsNV value) {
+  switch (value) {
+  case IndirectStateFlagBitsNV::eFlagFrontface:
+    return "FlagFrontface";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class IndirectCommandsTokenTypeNV {
+  eShaderGroup = VK_INDIRECT_COMMANDS_TOKEN_TYPE_SHADER_GROUP_NV,
+  eStateFlags = VK_INDIRECT_COMMANDS_TOKEN_TYPE_STATE_FLAGS_NV,
+  eIndexBuffer = VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NV,
+  eVertexBuffer = VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NV,
+  ePushConstant = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NV,
+  eDrawIndexed = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NV,
+  eDraw = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NV,
+  eDrawTasks = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_TASKS_NV
+};
+
+VULKAN_HPP_INLINE std::string to_string(IndirectCommandsTokenTypeNV value) {
+  switch (value) {
+  case IndirectCommandsTokenTypeNV::eShaderGroup:
+    return "ShaderGroup";
+  case IndirectCommandsTokenTypeNV::eStateFlags:
+    return "StateFlags";
+  case IndirectCommandsTokenTypeNV::eIndexBuffer:
+    return "IndexBuffer";
+  case IndirectCommandsTokenTypeNV::eVertexBuffer:
+    return "VertexBuffer";
+  case IndirectCommandsTokenTypeNV::ePushConstant:
+    return "PushConstant";
+  case IndirectCommandsTokenTypeNV::eDrawIndexed:
+    return "DrawIndexed";
+  case IndirectCommandsTokenTypeNV::eDraw:
+    return "Draw";
+  case IndirectCommandsTokenTypeNV::eDrawTasks:
+    return "DrawTasks";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class
+    IndirectCommandsLayoutUsageFlagBitsNV : VkIndirectCommandsLayoutUsageFlagsNV {
+      eExplicitPreprocess =
+          VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_NV,
+      eIndexedSequences =
+          VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NV,
+      eUnorderedSequences =
+          VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NV
+    };
+
+VULKAN_HPP_INLINE std::string
+to_string(IndirectCommandsLayoutUsageFlagBitsNV value) {
+  switch (value) {
+  case IndirectCommandsLayoutUsageFlagBitsNV::eExplicitPreprocess:
+    return "ExplicitPreprocess";
+  case IndirectCommandsLayoutUsageFlagBitsNV::eIndexedSequences:
+    return "IndexedSequences";
+  case IndirectCommandsLayoutUsageFlagBitsNV::eUnorderedSequences:
+    return "UnorderedSequences";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+//=== VK_EXT_device_memory_report ===
+
+enum class DeviceMemoryReportEventTypeEXT {
+  eAllocate = VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATE_EXT,
+  eFree = VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_FREE_EXT,
+  eImport = VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_IMPORT_EXT,
+  eUnimport = VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_UNIMPORT_EXT,
+  eAllocationFailed = VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATION_FAILED_EXT
+};
+
+VULKAN_HPP_INLINE std::string to_string(DeviceMemoryReportEventTypeEXT value) {
+  switch (value) {
+  case DeviceMemoryReportEventTypeEXT::eAllocate:
+    return "Allocate";
+  case DeviceMemoryReportEventTypeEXT::eFree:
+    return "Free";
+  case DeviceMemoryReportEventTypeEXT::eImport:
+    return "Import";
+  case DeviceMemoryReportEventTypeEXT::eUnimport:
+    return "Unimport";
+  case DeviceMemoryReportEventTypeEXT::eAllocationFailed:
+    return "AllocationFailed";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+//=== VK_EXT_private_data ===
+
+enum class PrivateDataSlotCreateFlagBitsEXT : VkPrivateDataSlotCreateFlagsEXT {
+};
+
+VULKAN_HPP_INLINE std::string to_string(PrivateDataSlotCreateFlagBitsEXT) {
+  return "(void)";
+}
+
+//=== VK_NV_device_diagnostics_config ===
+
+enum class
+    DeviceDiagnosticsConfigFlagBitsNV : VkDeviceDiagnosticsConfigFlagsNV {
+      eEnableShaderDebugInfo =
+          VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_DEBUG_INFO_BIT_NV,
+      eEnableResourceTracking =
+          VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_RESOURCE_TRACKING_BIT_NV,
+      eEnableAutomaticCheckpoints =
+          VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_AUTOMATIC_CHECKPOINTS_BIT_NV
+    };
+
+VULKAN_HPP_INLINE std::string
+to_string(DeviceDiagnosticsConfigFlagBitsNV value) {
+  switch (value) {
+  case DeviceDiagnosticsConfigFlagBitsNV::eEnableShaderDebugInfo:
+    return "EnableShaderDebugInfo";
+  case DeviceDiagnosticsConfigFlagBitsNV::eEnableResourceTracking:
+    return "EnableResourceTracking";
+  case DeviceDiagnosticsConfigFlagBitsNV::eEnableAutomaticCheckpoints:
+    return "EnableAutomaticCheckpoints";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+//=== VK_KHR_synchronization2 ===
+
+enum class PipelineStageFlagBits2KHR : VkPipelineStageFlags2KHR {
+  eNone = VK_PIPELINE_STAGE_2_NONE_KHR,
+  eTopOfPipe = VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT_KHR,
+  eDrawIndirect = VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT_KHR,
+  eVertexInput = VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT_KHR,
+  eVertexShader = VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT_KHR,
+  eTessellationControlShader =
+      VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT_KHR,
+  eTessellationEvaluationShader =
+      VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT_KHR,
+  eGeometryShader = VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT_KHR,
+  eFragmentShader = VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT_KHR,
+  eEarlyFragmentTests = VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT_KHR,
+  eLateFragmentTests = VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT_KHR,
+  eColorAttachmentOutput = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR,
+  eComputeShader = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT_KHR,
+  eAllTransfer = VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR,
+  eBottomOfPipe = VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT_KHR,
+  eHost = VK_PIPELINE_STAGE_2_HOST_BIT_KHR,
+  eAllGraphics = VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR,
+  eAllCommands = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR,
+  eCopy = VK_PIPELINE_STAGE_2_COPY_BIT_KHR,
+  eResolve = VK_PIPELINE_STAGE_2_RESOLVE_BIT_KHR,
+  eBlit = VK_PIPELINE_STAGE_2_BLIT_BIT_KHR,
+  eClear = VK_PIPELINE_STAGE_2_CLEAR_BIT_KHR,
+  eIndexInput = VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT_KHR,
+  eVertexAttributeInput = VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT_KHR,
+  ePreRasterizationShaders =
+      VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT_KHR,
+  eTransformFeedbackExt = VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT,
+  eConditionalRenderingExt = VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT,
+  eCommandPreprocessNv = VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV,
+  eFragmentShadingRateAttachment =
+      VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR,
+  eAccelerationStructureBuild =
+      VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR,
+  eRayTracingShader = VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR,
+  eFragmentDensityProcessExt =
+      VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT,
+  eTaskShaderNv = VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV,
+  eMeshShaderNv = VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV,
+  eAccelerationStructureBuildNv =
+      VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_NV,
+  eRayTracingShaderNv = VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_NV,
+  eShadingRateImageNv = VK_PIPELINE_STAGE_2_SHADING_RATE_IMAGE_BIT_NV,
+  eTransfer = VK_PIPELINE_STAGE_2_TRANSFER_BIT_KHR
+};
+
+VULKAN_HPP_INLINE std::string to_string(PipelineStageFlagBits2KHR value) {
+  switch (value) {
+  case PipelineStageFlagBits2KHR::eNone:
+    return "None";
+  case PipelineStageFlagBits2KHR::eTopOfPipe:
+    return "TopOfPipe";
+  case PipelineStageFlagBits2KHR::eDrawIndirect:
+    return "DrawIndirect";
+  case PipelineStageFlagBits2KHR::eVertexInput:
+    return "VertexInput";
+  case PipelineStageFlagBits2KHR::eVertexShader:
+    return "VertexShader";
+  case PipelineStageFlagBits2KHR::eTessellationControlShader:
+    return "TessellationControlShader";
+  case PipelineStageFlagBits2KHR::eTessellationEvaluationShader:
+    return "TessellationEvaluationShader";
+  case PipelineStageFlagBits2KHR::eGeometryShader:
+    return "GeometryShader";
+  case PipelineStageFlagBits2KHR::eFragmentShader:
+    return "FragmentShader";
+  case PipelineStageFlagBits2KHR::eEarlyFragmentTests:
+    return "EarlyFragmentTests";
+  case PipelineStageFlagBits2KHR::eLateFragmentTests:
+    return "LateFragmentTests";
+  case PipelineStageFlagBits2KHR::eColorAttachmentOutput:
+    return "ColorAttachmentOutput";
+  case PipelineStageFlagBits2KHR::eComputeShader:
+    return "ComputeShader";
+  case PipelineStageFlagBits2KHR::eAllTransfer:
+    return "AllTransfer";
+  case PipelineStageFlagBits2KHR::eBottomOfPipe:
+    return "BottomOfPipe";
+  case PipelineStageFlagBits2KHR::eHost:
+    return "Host";
+  case PipelineStageFlagBits2KHR::eAllGraphics:
+    return "AllGraphics";
+  case PipelineStageFlagBits2KHR::eAllCommands:
+    return "AllCommands";
+  case PipelineStageFlagBits2KHR::eCopy:
+    return "Copy";
+  case PipelineStageFlagBits2KHR::eResolve:
+    return "Resolve";
+  case PipelineStageFlagBits2KHR::eBlit:
+    return "Blit";
+  case PipelineStageFlagBits2KHR::eClear:
+    return "Clear";
+  case PipelineStageFlagBits2KHR::eIndexInput:
+    return "IndexInput";
+  case PipelineStageFlagBits2KHR::eVertexAttributeInput:
+    return "VertexAttributeInput";
+  case PipelineStageFlagBits2KHR::ePreRasterizationShaders:
+    return "PreRasterizationShaders";
+  case PipelineStageFlagBits2KHR::eTransformFeedbackExt:
+    return "TransformFeedbackExt";
+  case PipelineStageFlagBits2KHR::eConditionalRenderingExt:
+    return "ConditionalRenderingExt";
+  case PipelineStageFlagBits2KHR::eCommandPreprocessNv:
+    return "CommandPreprocessNv";
+  case PipelineStageFlagBits2KHR::eFragmentShadingRateAttachment:
+    return "FragmentShadingRateAttachment";
+  case PipelineStageFlagBits2KHR::eAccelerationStructureBuild:
+    return "AccelerationStructureBuild";
+  case PipelineStageFlagBits2KHR::eRayTracingShader:
+    return "RayTracingShader";
+  case PipelineStageFlagBits2KHR::eFragmentDensityProcessExt:
+    return "FragmentDensityProcessExt";
+  case PipelineStageFlagBits2KHR::eTaskShaderNv:
+    return "TaskShaderNv";
+  case PipelineStageFlagBits2KHR::eMeshShaderNv:
+    return "MeshShaderNv";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class AccessFlagBits2KHR : VkAccessFlags2KHR {
+  eNone = VK_ACCESS_2_NONE_KHR,
+  eIndirectCommandRead = VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT_KHR,
+  eIndexRead = VK_ACCESS_2_INDEX_READ_BIT_KHR,
+  eVertexAttributeRead = VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT_KHR,
+  eUniformRead = VK_ACCESS_2_UNIFORM_READ_BIT_KHR,
+  eInputAttachmentRead = VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT_KHR,
+  eShaderRead = VK_ACCESS_2_SHADER_READ_BIT_KHR,
+  eShaderWrite = VK_ACCESS_2_SHADER_WRITE_BIT_KHR,
+  eColorAttachmentRead = VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT_KHR,
+  eColorAttachmentWrite = VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT_KHR,
+  eDepthStencilAttachmentRead =
+      VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT_KHR,
+  eDepthStencilAttachmentWrite =
+      VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT_KHR,
+  eTransferRead = VK_ACCESS_2_TRANSFER_READ_BIT_KHR,
+  eTransferWrite = VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR,
+  eHostRead = VK_ACCESS_2_HOST_READ_BIT_KHR,
+  eHostWrite = VK_ACCESS_2_HOST_WRITE_BIT_KHR,
+  eMemoryRead = VK_ACCESS_2_MEMORY_READ_BIT_KHR,
+  eMemoryWrite = VK_ACCESS_2_MEMORY_WRITE_BIT_KHR,
+  eShaderSampledRead = VK_ACCESS_2_SHADER_SAMPLED_READ_BIT_KHR,
+  eShaderStorageRead = VK_ACCESS_2_SHADER_STORAGE_READ_BIT_KHR,
+  eShaderStorageWrite = VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT_KHR,
+  eTransformFeedbackWriteExt = VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT,
+  eTransformFeedbackCounterReadExt =
+      VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT,
+  eTransformFeedbackCounterWriteExt =
+      VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT,
+  eConditionalRenderingReadExt = VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT,
+  eCommandPreprocessReadNv = VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV,
+  eCommandPreprocessWriteNv = VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV,
+  eFragmentShadingRateAttachmentRead =
+      VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR,
+  eAccelerationStructureRead = VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR,
+  eAccelerationStructureWrite =
+      VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR,
+  eFragmentDensityMapReadExt = VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT,
+  eColorAttachmentReadNoncoherentExt =
+      VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT,
+  eAccelerationStructureReadNv = VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_NV,
+  eAccelerationStructureWriteNv =
+      VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_NV,
+  eShadingRateImageReadNv = VK_ACCESS_2_SHADING_RATE_IMAGE_READ_BIT_NV
+};
+
+VULKAN_HPP_INLINE std::string to_string(AccessFlagBits2KHR value) {
+  switch (value) {
+  case AccessFlagBits2KHR::eNone:
+    return "None";
+  case AccessFlagBits2KHR::eIndirectCommandRead:
+    return "IndirectCommandRead";
+  case AccessFlagBits2KHR::eIndexRead:
+    return "IndexRead";
+  case AccessFlagBits2KHR::eVertexAttributeRead:
+    return "VertexAttributeRead";
+  case AccessFlagBits2KHR::eUniformRead:
+    return "UniformRead";
+  case AccessFlagBits2KHR::eInputAttachmentRead:
+    return "InputAttachmentRead";
+  case AccessFlagBits2KHR::eShaderRead:
+    return "ShaderRead";
+  case AccessFlagBits2KHR::eShaderWrite:
+    return "ShaderWrite";
+  case AccessFlagBits2KHR::eColorAttachmentRead:
+    return "ColorAttachmentRead";
+  case AccessFlagBits2KHR::eColorAttachmentWrite:
+    return "ColorAttachmentWrite";
+  case AccessFlagBits2KHR::eDepthStencilAttachmentRead:
+    return "DepthStencilAttachmentRead";
+  case AccessFlagBits2KHR::eDepthStencilAttachmentWrite:
+    return "DepthStencilAttachmentWrite";
+  case AccessFlagBits2KHR::eTransferRead:
+    return "TransferRead";
+  case AccessFlagBits2KHR::eTransferWrite:
+    return "TransferWrite";
+  case AccessFlagBits2KHR::eHostRead:
+    return "HostRead";
+  case AccessFlagBits2KHR::eHostWrite:
+    return "HostWrite";
+  case AccessFlagBits2KHR::eMemoryRead:
+    return "MemoryRead";
+  case AccessFlagBits2KHR::eMemoryWrite:
+    return "MemoryWrite";
+  case AccessFlagBits2KHR::eShaderSampledRead:
+    return "ShaderSampledRead";
+  case AccessFlagBits2KHR::eShaderStorageRead:
+    return "ShaderStorageRead";
+  case AccessFlagBits2KHR::eShaderStorageWrite:
+    return "ShaderStorageWrite";
+  case AccessFlagBits2KHR::eTransformFeedbackWriteExt:
+    return "TransformFeedbackWriteExt";
+  case AccessFlagBits2KHR::eTransformFeedbackCounterReadExt:
+    return "TransformFeedbackCounterReadExt";
+  case AccessFlagBits2KHR::eTransformFeedbackCounterWriteExt:
+    return "TransformFeedbackCounterWriteExt";
+  case AccessFlagBits2KHR::eConditionalRenderingReadExt:
+    return "ConditionalRenderingReadExt";
+  case AccessFlagBits2KHR::eCommandPreprocessReadNv:
+    return "CommandPreprocessReadNv";
+  case AccessFlagBits2KHR::eCommandPreprocessWriteNv:
+    return "CommandPreprocessWriteNv";
+  case AccessFlagBits2KHR::eFragmentShadingRateAttachmentRead:
+    return "FragmentShadingRateAttachmentRead";
+  case AccessFlagBits2KHR::eAccelerationStructureRead:
+    return "AccelerationStructureRead";
+  case AccessFlagBits2KHR::eAccelerationStructureWrite:
+    return "AccelerationStructureWrite";
+  case AccessFlagBits2KHR::eFragmentDensityMapReadExt:
+    return "FragmentDensityMapReadExt";
+  case AccessFlagBits2KHR::eColorAttachmentReadNoncoherentExt:
+    return "ColorAttachmentReadNoncoherentExt";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class SubmitFlagBitsKHR : VkSubmitFlagsKHR {
+  eProtected = VK_SUBMIT_PROTECTED_BIT_KHR
+};
+
+VULKAN_HPP_INLINE std::string to_string(SubmitFlagBitsKHR value) {
+  switch (value) {
+  case SubmitFlagBitsKHR::eProtected:
+    return "Protected";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+//=== VK_NV_fragment_shading_rate_enums ===
+
+enum class FragmentShadingRateNV {
+  e1InvocationPerPixel = VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_PIXEL_NV,
+  e1InvocationPer1X2Pixels =
+      VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_1X2_PIXELS_NV,
+  e1InvocationPer2X1Pixels =
+      VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X1_PIXELS_NV,
+  e1InvocationPer2X2Pixels =
+      VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X2_PIXELS_NV,
+  e1InvocationPer2X4Pixels =
+      VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X4_PIXELS_NV,
+  e1InvocationPer4X2Pixels =
+      VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X2_PIXELS_NV,
+  e1InvocationPer4X4Pixels =
+      VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X4_PIXELS_NV,
+  e2InvocationsPerPixel = VK_FRAGMENT_SHADING_RATE_2_INVOCATIONS_PER_PIXEL_NV,
+  e4InvocationsPerPixel = VK_FRAGMENT_SHADING_RATE_4_INVOCATIONS_PER_PIXEL_NV,
+  e8InvocationsPerPixel = VK_FRAGMENT_SHADING_RATE_8_INVOCATIONS_PER_PIXEL_NV,
+  e16InvocationsPerPixel = VK_FRAGMENT_SHADING_RATE_16_INVOCATIONS_PER_PIXEL_NV,
+  eNoInvocations = VK_FRAGMENT_SHADING_RATE_NO_INVOCATIONS_NV
+};
+
+VULKAN_HPP_INLINE std::string to_string(FragmentShadingRateNV value) {
+  switch (value) {
+  case FragmentShadingRateNV::e1InvocationPerPixel:
+    return "1InvocationPerPixel";
+  case FragmentShadingRateNV::e1InvocationPer1X2Pixels:
+    return "1InvocationPer1X2Pixels";
+  case FragmentShadingRateNV::e1InvocationPer2X1Pixels:
+    return "1InvocationPer2X1Pixels";
+  case FragmentShadingRateNV::e1InvocationPer2X2Pixels:
+    return "1InvocationPer2X2Pixels";
+  case FragmentShadingRateNV::e1InvocationPer2X4Pixels:
+    return "1InvocationPer2X4Pixels";
+  case FragmentShadingRateNV::e1InvocationPer4X2Pixels:
+    return "1InvocationPer4X2Pixels";
+  case FragmentShadingRateNV::e1InvocationPer4X4Pixels:
+    return "1InvocationPer4X4Pixels";
+  case FragmentShadingRateNV::e2InvocationsPerPixel:
+    return "2InvocationsPerPixel";
+  case FragmentShadingRateNV::e4InvocationsPerPixel:
+    return "4InvocationsPerPixel";
+  case FragmentShadingRateNV::e8InvocationsPerPixel:
+    return "8InvocationsPerPixel";
+  case FragmentShadingRateNV::e16InvocationsPerPixel:
+    return "16InvocationsPerPixel";
+  case FragmentShadingRateNV::eNoInvocations:
+    return "NoInvocations";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class FragmentShadingRateTypeNV {
+  eFragmentSize = VK_FRAGMENT_SHADING_RATE_TYPE_FRAGMENT_SIZE_NV,
+  eEnums = VK_FRAGMENT_SHADING_RATE_TYPE_ENUMS_NV
+};
+
+VULKAN_HPP_INLINE std::string to_string(FragmentShadingRateTypeNV value) {
+  switch (value) {
+  case FragmentShadingRateTypeNV::eFragmentSize:
+    return "FragmentSize";
+  case FragmentShadingRateTypeNV::eEnums:
+    return "Enums";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+//=== VK_KHR_ray_tracing_pipeline ===
+
+enum class RayTracingShaderGroupTypeKHR {
+  eGeneral = VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR,
+  eTrianglesHitGroup = VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR,
+  eProceduralHitGroup =
+      VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR
+};
+using RayTracingShaderGroupTypeNV = RayTracingShaderGroupTypeKHR;
+
+VULKAN_HPP_INLINE std::string to_string(RayTracingShaderGroupTypeKHR value) {
+  switch (value) {
+  case RayTracingShaderGroupTypeKHR::eGeneral:
+    return "General";
+  case RayTracingShaderGroupTypeKHR::eTrianglesHitGroup:
+    return "TrianglesHitGroup";
+  case RayTracingShaderGroupTypeKHR::eProceduralHitGroup:
+    return "ProceduralHitGroup";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+enum class ShaderGroupShaderKHR {
+  eGeneral = VK_SHADER_GROUP_SHADER_GENERAL_KHR,
+  eClosestHit = VK_SHADER_GROUP_SHADER_CLOSEST_HIT_KHR,
+  eAnyHit = VK_SHADER_GROUP_SHADER_ANY_HIT_KHR,
+  eIntersection = VK_SHADER_GROUP_SHADER_INTERSECTION_KHR
+};
+
+VULKAN_HPP_INLINE std::string to_string(ShaderGroupShaderKHR value) {
+  switch (value) {
+  case ShaderGroupShaderKHR::eGeneral:
+    return "General";
+  case ShaderGroupShaderKHR::eClosestHit:
+    return "ClosestHit";
+  case ShaderGroupShaderKHR::eAnyHit:
+    return "AnyHit";
+  case ShaderGroupShaderKHR::eIntersection:
+    return "Intersection";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+
+//=== VK_FUCHSIA_memory_control ===
+
+enum class MemoryOpFlagBitsFUCHSIA : VkMemoryOpFlagsFUCHSIA {
+  eUnpin = VK_MEMORY_OP_UNPIN_BIT_FUCHSIA,
+  eDecommit = VK_MEMORY_OP_DECOMMIT_BIT_FUCHSIA,
+  ePin = VK_MEMORY_OP_PIN_BIT_FUCHSIA,
+  eCommit = VK_MEMORY_OP_COMMIT_BIT_FUCHSIA,
+  eLock = VK_MEMORY_OP_LOCK_BIT_FUCHSIA,
+  eUnlock = VK_MEMORY_OP_UNLOCK_BIT_FUCHSIA
+};
+
+VULKAN_HPP_INLINE std::string to_string(MemoryOpFlagBitsFUCHSIA value) {
+  switch (value) {
+  case MemoryOpFlagBitsFUCHSIA::eUnpin:
+    return "Unpin";
+  case MemoryOpFlagBitsFUCHSIA::eDecommit:
+    return "Decommit";
+  case MemoryOpFlagBitsFUCHSIA::ePin:
+    return "Pin";
+  case MemoryOpFlagBitsFUCHSIA::eCommit:
+    return "Commit";
+  case MemoryOpFlagBitsFUCHSIA::eLock:
+    return "Lock";
+  case MemoryOpFlagBitsFUCHSIA::eUnlock:
+    return "Unlock";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+
+//=== VK_FUCHSIA_buffer_collection_x ===
+
+enum class
+    ImageFormatConstraintsFlagBitsFUCHSIAX : VkImageFormatConstraintsFlagsFUCHSIAX {
+    };
+
+VULKAN_HPP_INLINE std::string
+to_string(ImageFormatConstraintsFlagBitsFUCHSIAX) {
+  return "(void)";
+}
+
+enum class
+    ImageConstraintsInfoFlagBitsFUCHSIAX : VkImageConstraintsInfoFlagsFUCHSIAX {
+      eVkImageConstraintsInfoCpuReadRarelyFuchsiax =
+          VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_RARELY_FUCHSIAX,
+      eVkImageConstraintsInfoCpuReadOftenFuchsiax =
+          VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_OFTEN_FUCHSIAX,
+      eVkImageConstraintsInfoCpuWriteRarelyFuchsiax =
+          VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_RARELY_FUCHSIAX,
+      eVkImageConstraintsInfoCpuWriteOftenFuchsiax =
+          VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_OFTEN_FUCHSIAX,
+      eVkImageConstraintsInfoProtectedOptionalFuchsiax =
+          VK_IMAGE_CONSTRAINTS_INFO_PROTECTED_OPTIONAL_FUCHSIAX
+    };
+
+VULKAN_HPP_INLINE std::string
+to_string(ImageConstraintsInfoFlagBitsFUCHSIAX value) {
+  switch (value) {
+  case ImageConstraintsInfoFlagBitsFUCHSIAX::
+      eVkImageConstraintsInfoCpuReadRarelyFuchsiax:
+    return "VkImageConstraintsInfoCpuReadRarelyFuchsiax";
+  case ImageConstraintsInfoFlagBitsFUCHSIAX::
+      eVkImageConstraintsInfoCpuReadOftenFuchsiax:
+    return "VkImageConstraintsInfoCpuReadOftenFuchsiax";
+  case ImageConstraintsInfoFlagBitsFUCHSIAX::
+      eVkImageConstraintsInfoCpuWriteRarelyFuchsiax:
+    return "VkImageConstraintsInfoCpuWriteRarelyFuchsiax";
+  case ImageConstraintsInfoFlagBitsFUCHSIAX::
+      eVkImageConstraintsInfoCpuWriteOftenFuchsiax:
+    return "VkImageConstraintsInfoCpuWriteOftenFuchsiax";
+  case ImageConstraintsInfoFlagBitsFUCHSIAX::
+      eVkImageConstraintsInfoProtectedOptionalFuchsiax:
+    return "VkImageConstraintsInfoProtectedOptionalFuchsiax";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+
+//=== VK_FUCHSIA_buffer_collection ===
+
+enum class
+    ImageFormatConstraintsFlagBitsFUCHSIA : VkImageFormatConstraintsFlagsFUCHSIA {
+    };
+
+VULKAN_HPP_INLINE std::string to_string(ImageFormatConstraintsFlagBitsFUCHSIA) {
+  return "(void)";
+}
+
+enum class
+    ImageConstraintsInfoFlagBitsFUCHSIA : VkImageConstraintsInfoFlagsFUCHSIA {
+      eCpuReadRarely = VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_RARELY_FUCHSIA,
+      eCpuReadOften = VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_OFTEN_FUCHSIA,
+      eCpuWriteRarely = VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_RARELY_FUCHSIA,
+      eCpuWriteOften = VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_OFTEN_FUCHSIA,
+      eProtectedOptional = VK_IMAGE_CONSTRAINTS_INFO_PROTECTED_OPTIONAL_FUCHSIA
+    };
+
+VULKAN_HPP_INLINE std::string
+to_string(ImageConstraintsInfoFlagBitsFUCHSIA value) {
+  switch (value) {
+  case ImageConstraintsInfoFlagBitsFUCHSIA::eCpuReadRarely:
+    return "CpuReadRarely";
+  case ImageConstraintsInfoFlagBitsFUCHSIA::eCpuReadOften:
+    return "CpuReadOften";
+  case ImageConstraintsInfoFlagBitsFUCHSIA::eCpuWriteRarely:
+    return "CpuWriteRarely";
+  case ImageConstraintsInfoFlagBitsFUCHSIA::eCpuWriteOften:
+    return "CpuWriteOften";
+  case ImageConstraintsInfoFlagBitsFUCHSIA::eProtectedOptional:
+    return "ProtectedOptional";
+  default:
+    return "invalid ( " +
+           VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) +
+           " )";
+  }
+}
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+
+template <ObjectType value> struct cpp_type {};
 
 template <typename T> struct IndexTypeValue {};
 
@@ -13412,2176 +14319,11 @@
   using Type = uint8_t;
 };
 
-using AccelerationStructureCreateFlagsKHR =
-    Flags<AccelerationStructureCreateFlagBitsKHR>;
+//================
+//=== BITMASKs ===
+//================
 
-template <> struct FlagTraits<AccelerationStructureCreateFlagBitsKHR> {
-  enum : VkFlags {
-    allFlags = VkFlags(
-        AccelerationStructureCreateFlagBitsKHR::eDeviceAddressCaptureReplay)
-  };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR AccelerationStructureCreateFlagsKHR
-operator|(AccelerationStructureCreateFlagBitsKHR bit0,
-          AccelerationStructureCreateFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
-  return AccelerationStructureCreateFlagsKHR(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR AccelerationStructureCreateFlagsKHR
-operator&(AccelerationStructureCreateFlagBitsKHR bit0,
-          AccelerationStructureCreateFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
-  return AccelerationStructureCreateFlagsKHR(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR AccelerationStructureCreateFlagsKHR
-operator^(AccelerationStructureCreateFlagBitsKHR bit0,
-          AccelerationStructureCreateFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
-  return AccelerationStructureCreateFlagsKHR(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR AccelerationStructureCreateFlagsKHR
-operator~(AccelerationStructureCreateFlagBitsKHR bits) VULKAN_HPP_NOEXCEPT {
-  return ~(AccelerationStructureCreateFlagsKHR(bits));
-}
-
-VULKAN_HPP_INLINE std::string
-to_string(AccelerationStructureCreateFlagsKHR value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value &
-      AccelerationStructureCreateFlagBitsKHR::eDeviceAddressCaptureReplay)
-    result += "DeviceAddressCaptureReplay | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-using AccessFlags = Flags<AccessFlagBits>;
-
-template <> struct FlagTraits<AccessFlagBits> {
-  enum : VkFlags {
-    allFlags = VkFlags(AccessFlagBits::eIndirectCommandRead) |
-               VkFlags(AccessFlagBits::eIndexRead) |
-               VkFlags(AccessFlagBits::eVertexAttributeRead) |
-               VkFlags(AccessFlagBits::eUniformRead) |
-               VkFlags(AccessFlagBits::eInputAttachmentRead) |
-               VkFlags(AccessFlagBits::eShaderRead) |
-               VkFlags(AccessFlagBits::eShaderWrite) |
-               VkFlags(AccessFlagBits::eColorAttachmentRead) |
-               VkFlags(AccessFlagBits::eColorAttachmentWrite) |
-               VkFlags(AccessFlagBits::eDepthStencilAttachmentRead) |
-               VkFlags(AccessFlagBits::eDepthStencilAttachmentWrite) |
-               VkFlags(AccessFlagBits::eTransferRead) |
-               VkFlags(AccessFlagBits::eTransferWrite) |
-               VkFlags(AccessFlagBits::eHostRead) |
-               VkFlags(AccessFlagBits::eHostWrite) |
-               VkFlags(AccessFlagBits::eMemoryRead) |
-               VkFlags(AccessFlagBits::eMemoryWrite) |
-               VkFlags(AccessFlagBits::eTransformFeedbackWriteEXT) |
-               VkFlags(AccessFlagBits::eTransformFeedbackCounterReadEXT) |
-               VkFlags(AccessFlagBits::eTransformFeedbackCounterWriteEXT) |
-               VkFlags(AccessFlagBits::eConditionalRenderingReadEXT) |
-               VkFlags(AccessFlagBits::eColorAttachmentReadNoncoherentEXT) |
-               VkFlags(AccessFlagBits::eAccelerationStructureReadKHR) |
-               VkFlags(AccessFlagBits::eAccelerationStructureWriteKHR) |
-               VkFlags(AccessFlagBits::eShadingRateImageReadNV) |
-               VkFlags(AccessFlagBits::eFragmentDensityMapReadEXT) |
-               VkFlags(AccessFlagBits::eCommandPreprocessReadNV) |
-               VkFlags(AccessFlagBits::eCommandPreprocessWriteNV) |
-               VkFlags(AccessFlagBits::eNoneKHR)
-  };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR AccessFlags
-operator|(AccessFlagBits bit0, AccessFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return AccessFlags(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR AccessFlags
-operator&(AccessFlagBits bit0, AccessFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return AccessFlags(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR AccessFlags
-operator^(AccessFlagBits bit0, AccessFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return AccessFlags(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR AccessFlags
-operator~(AccessFlagBits bits) VULKAN_HPP_NOEXCEPT {
-  return ~(AccessFlags(bits));
-}
-
-VULKAN_HPP_INLINE std::string to_string(AccessFlags value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & AccessFlagBits::eIndirectCommandRead)
-    result += "IndirectCommandRead | ";
-  if (value & AccessFlagBits::eIndexRead)
-    result += "IndexRead | ";
-  if (value & AccessFlagBits::eVertexAttributeRead)
-    result += "VertexAttributeRead | ";
-  if (value & AccessFlagBits::eUniformRead)
-    result += "UniformRead | ";
-  if (value & AccessFlagBits::eInputAttachmentRead)
-    result += "InputAttachmentRead | ";
-  if (value & AccessFlagBits::eShaderRead)
-    result += "ShaderRead | ";
-  if (value & AccessFlagBits::eShaderWrite)
-    result += "ShaderWrite | ";
-  if (value & AccessFlagBits::eColorAttachmentRead)
-    result += "ColorAttachmentRead | ";
-  if (value & AccessFlagBits::eColorAttachmentWrite)
-    result += "ColorAttachmentWrite | ";
-  if (value & AccessFlagBits::eDepthStencilAttachmentRead)
-    result += "DepthStencilAttachmentRead | ";
-  if (value & AccessFlagBits::eDepthStencilAttachmentWrite)
-    result += "DepthStencilAttachmentWrite | ";
-  if (value & AccessFlagBits::eTransferRead)
-    result += "TransferRead | ";
-  if (value & AccessFlagBits::eTransferWrite)
-    result += "TransferWrite | ";
-  if (value & AccessFlagBits::eHostRead)
-    result += "HostRead | ";
-  if (value & AccessFlagBits::eHostWrite)
-    result += "HostWrite | ";
-  if (value & AccessFlagBits::eMemoryRead)
-    result += "MemoryRead | ";
-  if (value & AccessFlagBits::eMemoryWrite)
-    result += "MemoryWrite | ";
-  if (value & AccessFlagBits::eTransformFeedbackWriteEXT)
-    result += "TransformFeedbackWriteEXT | ";
-  if (value & AccessFlagBits::eTransformFeedbackCounterReadEXT)
-    result += "TransformFeedbackCounterReadEXT | ";
-  if (value & AccessFlagBits::eTransformFeedbackCounterWriteEXT)
-    result += "TransformFeedbackCounterWriteEXT | ";
-  if (value & AccessFlagBits::eConditionalRenderingReadEXT)
-    result += "ConditionalRenderingReadEXT | ";
-  if (value & AccessFlagBits::eColorAttachmentReadNoncoherentEXT)
-    result += "ColorAttachmentReadNoncoherentEXT | ";
-  if (value & AccessFlagBits::eAccelerationStructureReadKHR)
-    result += "AccelerationStructureReadKHR | ";
-  if (value & AccessFlagBits::eAccelerationStructureWriteKHR)
-    result += "AccelerationStructureWriteKHR | ";
-  if (value & AccessFlagBits::eShadingRateImageReadNV)
-    result += "ShadingRateImageReadNV | ";
-  if (value & AccessFlagBits::eFragmentDensityMapReadEXT)
-    result += "FragmentDensityMapReadEXT | ";
-  if (value & AccessFlagBits::eCommandPreprocessReadNV)
-    result += "CommandPreprocessReadNV | ";
-  if (value & AccessFlagBits::eCommandPreprocessWriteNV)
-    result += "CommandPreprocessWriteNV | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-using AccessFlags2KHR = Flags<AccessFlagBits2KHR>;
-
-template <> struct FlagTraits<AccessFlagBits2KHR> {
-  enum : VkFlags64 {
-    allFlags =
-        VkFlags64(AccessFlagBits2KHR::eNone) |
-        VkFlags64(AccessFlagBits2KHR::eIndirectCommandRead) |
-        VkFlags64(AccessFlagBits2KHR::eIndexRead) |
-        VkFlags64(AccessFlagBits2KHR::eVertexAttributeRead) |
-        VkFlags64(AccessFlagBits2KHR::eUniformRead) |
-        VkFlags64(AccessFlagBits2KHR::eInputAttachmentRead) |
-        VkFlags64(AccessFlagBits2KHR::eShaderRead) |
-        VkFlags64(AccessFlagBits2KHR::eShaderWrite) |
-        VkFlags64(AccessFlagBits2KHR::eColorAttachmentRead) |
-        VkFlags64(AccessFlagBits2KHR::eColorAttachmentWrite) |
-        VkFlags64(AccessFlagBits2KHR::eDepthStencilAttachmentRead) |
-        VkFlags64(AccessFlagBits2KHR::eDepthStencilAttachmentWrite) |
-        VkFlags64(AccessFlagBits2KHR::eTransferRead) |
-        VkFlags64(AccessFlagBits2KHR::eTransferWrite) |
-        VkFlags64(AccessFlagBits2KHR::eHostRead) |
-        VkFlags64(AccessFlagBits2KHR::eHostWrite) |
-        VkFlags64(AccessFlagBits2KHR::eMemoryRead) |
-        VkFlags64(AccessFlagBits2KHR::eMemoryWrite) |
-        VkFlags64(AccessFlagBits2KHR::eShaderSampledRead) |
-        VkFlags64(AccessFlagBits2KHR::eShaderStorageRead) |
-        VkFlags64(AccessFlagBits2KHR::eShaderStorageWrite) |
-        VkFlags64(AccessFlagBits2KHR::eTransformFeedbackWriteExt) |
-        VkFlags64(AccessFlagBits2KHR::eTransformFeedbackCounterReadExt) |
-        VkFlags64(AccessFlagBits2KHR::eTransformFeedbackCounterWriteExt) |
-        VkFlags64(AccessFlagBits2KHR::eConditionalRenderingReadExt) |
-        VkFlags64(AccessFlagBits2KHR::eCommandPreprocessReadNv) |
-        VkFlags64(AccessFlagBits2KHR::eCommandPreprocessWriteNv) |
-        VkFlags64(AccessFlagBits2KHR::eFragmentShadingRateAttachmentRead) |
-        VkFlags64(AccessFlagBits2KHR::eAccelerationStructureRead) |
-        VkFlags64(AccessFlagBits2KHR::eAccelerationStructureWrite) |
-        VkFlags64(AccessFlagBits2KHR::eFragmentDensityMapReadExt) |
-        VkFlags64(AccessFlagBits2KHR::eColorAttachmentReadNoncoherentExt)
-  };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR AccessFlags2KHR operator|(
-    AccessFlagBits2KHR bit0, AccessFlagBits2KHR bit1) VULKAN_HPP_NOEXCEPT {
-  return AccessFlags2KHR(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR AccessFlags2KHR operator&(
-    AccessFlagBits2KHR bit0, AccessFlagBits2KHR bit1) VULKAN_HPP_NOEXCEPT {
-  return AccessFlags2KHR(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR AccessFlags2KHR operator^(
-    AccessFlagBits2KHR bit0, AccessFlagBits2KHR bit1) VULKAN_HPP_NOEXCEPT {
-  return AccessFlags2KHR(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR AccessFlags2KHR
-operator~(AccessFlagBits2KHR bits) VULKAN_HPP_NOEXCEPT {
-  return ~(AccessFlags2KHR(bits));
-}
-
-VULKAN_HPP_INLINE std::string to_string(AccessFlags2KHR value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & AccessFlagBits2KHR::eIndirectCommandRead)
-    result += "IndirectCommandRead | ";
-  if (value & AccessFlagBits2KHR::eIndexRead)
-    result += "IndexRead | ";
-  if (value & AccessFlagBits2KHR::eVertexAttributeRead)
-    result += "VertexAttributeRead | ";
-  if (value & AccessFlagBits2KHR::eUniformRead)
-    result += "UniformRead | ";
-  if (value & AccessFlagBits2KHR::eInputAttachmentRead)
-    result += "InputAttachmentRead | ";
-  if (value & AccessFlagBits2KHR::eShaderRead)
-    result += "ShaderRead | ";
-  if (value & AccessFlagBits2KHR::eShaderWrite)
-    result += "ShaderWrite | ";
-  if (value & AccessFlagBits2KHR::eColorAttachmentRead)
-    result += "ColorAttachmentRead | ";
-  if (value & AccessFlagBits2KHR::eColorAttachmentWrite)
-    result += "ColorAttachmentWrite | ";
-  if (value & AccessFlagBits2KHR::eDepthStencilAttachmentRead)
-    result += "DepthStencilAttachmentRead | ";
-  if (value & AccessFlagBits2KHR::eDepthStencilAttachmentWrite)
-    result += "DepthStencilAttachmentWrite | ";
-  if (value & AccessFlagBits2KHR::eTransferRead)
-    result += "TransferRead | ";
-  if (value & AccessFlagBits2KHR::eTransferWrite)
-    result += "TransferWrite | ";
-  if (value & AccessFlagBits2KHR::eHostRead)
-    result += "HostRead | ";
-  if (value & AccessFlagBits2KHR::eHostWrite)
-    result += "HostWrite | ";
-  if (value & AccessFlagBits2KHR::eMemoryRead)
-    result += "MemoryRead | ";
-  if (value & AccessFlagBits2KHR::eMemoryWrite)
-    result += "MemoryWrite | ";
-  if (value & AccessFlagBits2KHR::eShaderSampledRead)
-    result += "ShaderSampledRead | ";
-  if (value & AccessFlagBits2KHR::eShaderStorageRead)
-    result += "ShaderStorageRead | ";
-  if (value & AccessFlagBits2KHR::eShaderStorageWrite)
-    result += "ShaderStorageWrite | ";
-  if (value & AccessFlagBits2KHR::eTransformFeedbackWriteExt)
-    result += "TransformFeedbackWriteExt | ";
-  if (value & AccessFlagBits2KHR::eTransformFeedbackCounterReadExt)
-    result += "TransformFeedbackCounterReadExt | ";
-  if (value & AccessFlagBits2KHR::eTransformFeedbackCounterWriteExt)
-    result += "TransformFeedbackCounterWriteExt | ";
-  if (value & AccessFlagBits2KHR::eConditionalRenderingReadExt)
-    result += "ConditionalRenderingReadExt | ";
-  if (value & AccessFlagBits2KHR::eCommandPreprocessReadNv)
-    result += "CommandPreprocessReadNv | ";
-  if (value & AccessFlagBits2KHR::eCommandPreprocessWriteNv)
-    result += "CommandPreprocessWriteNv | ";
-  if (value & AccessFlagBits2KHR::eFragmentShadingRateAttachmentRead)
-    result += "FragmentShadingRateAttachmentRead | ";
-  if (value & AccessFlagBits2KHR::eAccelerationStructureRead)
-    result += "AccelerationStructureRead | ";
-  if (value & AccessFlagBits2KHR::eAccelerationStructureWrite)
-    result += "AccelerationStructureWrite | ";
-  if (value & AccessFlagBits2KHR::eFragmentDensityMapReadExt)
-    result += "FragmentDensityMapReadExt | ";
-  if (value & AccessFlagBits2KHR::eColorAttachmentReadNoncoherentExt)
-    result += "ColorAttachmentReadNoncoherentExt | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-using AcquireProfilingLockFlagsKHR = Flags<AcquireProfilingLockFlagBitsKHR>;
-
-VULKAN_HPP_INLINE std::string to_string(AcquireProfilingLockFlagsKHR) {
-
-  return "{}";
-}
-
-#if defined(VK_USE_PLATFORM_ANDROID_KHR)
-enum class AndroidSurfaceCreateFlagBitsKHR : VkFlags {};
-
-VULKAN_HPP_INLINE std::string to_string(AndroidSurfaceCreateFlagBitsKHR) {
-  return "(void)";
-}
-
-using AndroidSurfaceCreateFlagsKHR = Flags<AndroidSurfaceCreateFlagBitsKHR>;
-
-VULKAN_HPP_INLINE std::string to_string(AndroidSurfaceCreateFlagsKHR) {
-
-  return "{}";
-}
-#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
-
-using AttachmentDescriptionFlags = Flags<AttachmentDescriptionFlagBits>;
-
-template <> struct FlagTraits<AttachmentDescriptionFlagBits> {
-  enum : VkFlags {
-    allFlags = VkFlags(AttachmentDescriptionFlagBits::eMayAlias)
-  };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR AttachmentDescriptionFlags
-operator|(AttachmentDescriptionFlagBits bit0,
-          AttachmentDescriptionFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return AttachmentDescriptionFlags(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR AttachmentDescriptionFlags
-operator&(AttachmentDescriptionFlagBits bit0,
-          AttachmentDescriptionFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return AttachmentDescriptionFlags(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR AttachmentDescriptionFlags
-operator^(AttachmentDescriptionFlagBits bit0,
-          AttachmentDescriptionFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return AttachmentDescriptionFlags(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR AttachmentDescriptionFlags
-operator~(AttachmentDescriptionFlagBits bits) VULKAN_HPP_NOEXCEPT {
-  return ~(AttachmentDescriptionFlags(bits));
-}
-
-VULKAN_HPP_INLINE std::string to_string(AttachmentDescriptionFlags value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & AttachmentDescriptionFlagBits::eMayAlias)
-    result += "MayAlias | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-using BufferCreateFlags = Flags<BufferCreateFlagBits>;
-
-template <> struct FlagTraits<BufferCreateFlagBits> {
-  enum : VkFlags {
-    allFlags = VkFlags(BufferCreateFlagBits::eSparseBinding) |
-               VkFlags(BufferCreateFlagBits::eSparseResidency) |
-               VkFlags(BufferCreateFlagBits::eSparseAliased) |
-               VkFlags(BufferCreateFlagBits::eProtected) |
-               VkFlags(BufferCreateFlagBits::eDeviceAddressCaptureReplay)
-  };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR BufferCreateFlags operator|(
-    BufferCreateFlagBits bit0, BufferCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return BufferCreateFlags(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR BufferCreateFlags operator&(
-    BufferCreateFlagBits bit0, BufferCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return BufferCreateFlags(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR BufferCreateFlags operator^(
-    BufferCreateFlagBits bit0, BufferCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return BufferCreateFlags(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR BufferCreateFlags
-operator~(BufferCreateFlagBits bits) VULKAN_HPP_NOEXCEPT {
-  return ~(BufferCreateFlags(bits));
-}
-
-VULKAN_HPP_INLINE std::string to_string(BufferCreateFlags value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & BufferCreateFlagBits::eSparseBinding)
-    result += "SparseBinding | ";
-  if (value & BufferCreateFlagBits::eSparseResidency)
-    result += "SparseResidency | ";
-  if (value & BufferCreateFlagBits::eSparseAliased)
-    result += "SparseAliased | ";
-  if (value & BufferCreateFlagBits::eProtected)
-    result += "Protected | ";
-  if (value & BufferCreateFlagBits::eDeviceAddressCaptureReplay)
-    result += "DeviceAddressCaptureReplay | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-using BufferUsageFlags = Flags<BufferUsageFlagBits>;
-
-template <> struct FlagTraits<BufferUsageFlagBits> {
-  enum : VkFlags {
-    allFlags =
-        VkFlags(BufferUsageFlagBits::eTransferSrc) |
-        VkFlags(BufferUsageFlagBits::eTransferDst) |
-        VkFlags(BufferUsageFlagBits::eUniformTexelBuffer) |
-        VkFlags(BufferUsageFlagBits::eStorageTexelBuffer) |
-        VkFlags(BufferUsageFlagBits::eUniformBuffer) |
-        VkFlags(BufferUsageFlagBits::eStorageBuffer) |
-        VkFlags(BufferUsageFlagBits::eIndexBuffer) |
-        VkFlags(BufferUsageFlagBits::eVertexBuffer) |
-        VkFlags(BufferUsageFlagBits::eIndirectBuffer) |
-        VkFlags(BufferUsageFlagBits::eShaderDeviceAddress) |
-        VkFlags(BufferUsageFlagBits::eTransformFeedbackBufferEXT) |
-        VkFlags(BufferUsageFlagBits::eTransformFeedbackCounterBufferEXT) |
-        VkFlags(BufferUsageFlagBits::eConditionalRenderingEXT) |
-        VkFlags(
-            BufferUsageFlagBits::eAccelerationStructureBuildInputReadOnlyKHR) |
-        VkFlags(BufferUsageFlagBits::eAccelerationStructureStorageKHR) |
-        VkFlags(BufferUsageFlagBits::eShaderBindingTableKHR)
-  };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR BufferUsageFlags operator|(
-    BufferUsageFlagBits bit0, BufferUsageFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return BufferUsageFlags(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR BufferUsageFlags operator&(
-    BufferUsageFlagBits bit0, BufferUsageFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return BufferUsageFlags(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR BufferUsageFlags operator^(
-    BufferUsageFlagBits bit0, BufferUsageFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return BufferUsageFlags(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR BufferUsageFlags
-operator~(BufferUsageFlagBits bits) VULKAN_HPP_NOEXCEPT {
-  return ~(BufferUsageFlags(bits));
-}
-
-VULKAN_HPP_INLINE std::string to_string(BufferUsageFlags value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & BufferUsageFlagBits::eTransferSrc)
-    result += "TransferSrc | ";
-  if (value & BufferUsageFlagBits::eTransferDst)
-    result += "TransferDst | ";
-  if (value & BufferUsageFlagBits::eUniformTexelBuffer)
-    result += "UniformTexelBuffer | ";
-  if (value & BufferUsageFlagBits::eStorageTexelBuffer)
-    result += "StorageTexelBuffer | ";
-  if (value & BufferUsageFlagBits::eUniformBuffer)
-    result += "UniformBuffer | ";
-  if (value & BufferUsageFlagBits::eStorageBuffer)
-    result += "StorageBuffer | ";
-  if (value & BufferUsageFlagBits::eIndexBuffer)
-    result += "IndexBuffer | ";
-  if (value & BufferUsageFlagBits::eVertexBuffer)
-    result += "VertexBuffer | ";
-  if (value & BufferUsageFlagBits::eIndirectBuffer)
-    result += "IndirectBuffer | ";
-  if (value & BufferUsageFlagBits::eShaderDeviceAddress)
-    result += "ShaderDeviceAddress | ";
-  if (value & BufferUsageFlagBits::eTransformFeedbackBufferEXT)
-    result += "TransformFeedbackBufferEXT | ";
-  if (value & BufferUsageFlagBits::eTransformFeedbackCounterBufferEXT)
-    result += "TransformFeedbackCounterBufferEXT | ";
-  if (value & BufferUsageFlagBits::eConditionalRenderingEXT)
-    result += "ConditionalRenderingEXT | ";
-  if (value & BufferUsageFlagBits::eAccelerationStructureBuildInputReadOnlyKHR)
-    result += "AccelerationStructureBuildInputReadOnlyKHR | ";
-  if (value & BufferUsageFlagBits::eAccelerationStructureStorageKHR)
-    result += "AccelerationStructureStorageKHR | ";
-  if (value & BufferUsageFlagBits::eShaderBindingTableKHR)
-    result += "ShaderBindingTableKHR | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-enum class BufferViewCreateFlagBits : VkFlags {};
-
-VULKAN_HPP_INLINE std::string to_string(BufferViewCreateFlagBits) {
-  return "(void)";
-}
-
-using BufferViewCreateFlags = Flags<BufferViewCreateFlagBits>;
-
-VULKAN_HPP_INLINE std::string to_string(BufferViewCreateFlags) { return "{}"; }
-
-using BuildAccelerationStructureFlagsKHR =
-    Flags<BuildAccelerationStructureFlagBitsKHR>;
-
-template <> struct FlagTraits<BuildAccelerationStructureFlagBitsKHR> {
-  enum : VkFlags {
-    allFlags =
-        VkFlags(BuildAccelerationStructureFlagBitsKHR::eAllowUpdate) |
-        VkFlags(BuildAccelerationStructureFlagBitsKHR::eAllowCompaction) |
-        VkFlags(BuildAccelerationStructureFlagBitsKHR::ePreferFastTrace) |
-        VkFlags(BuildAccelerationStructureFlagBitsKHR::ePreferFastBuild) |
-        VkFlags(BuildAccelerationStructureFlagBitsKHR::eLowMemory)
-  };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR BuildAccelerationStructureFlagsKHR
-operator|(BuildAccelerationStructureFlagBitsKHR bit0,
-          BuildAccelerationStructureFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
-  return BuildAccelerationStructureFlagsKHR(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR BuildAccelerationStructureFlagsKHR
-operator&(BuildAccelerationStructureFlagBitsKHR bit0,
-          BuildAccelerationStructureFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
-  return BuildAccelerationStructureFlagsKHR(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR BuildAccelerationStructureFlagsKHR
-operator^(BuildAccelerationStructureFlagBitsKHR bit0,
-          BuildAccelerationStructureFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
-  return BuildAccelerationStructureFlagsKHR(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR BuildAccelerationStructureFlagsKHR
-operator~(BuildAccelerationStructureFlagBitsKHR bits) VULKAN_HPP_NOEXCEPT {
-  return ~(BuildAccelerationStructureFlagsKHR(bits));
-}
-
-using BuildAccelerationStructureFlagsNV = BuildAccelerationStructureFlagsKHR;
-
-VULKAN_HPP_INLINE std::string
-to_string(BuildAccelerationStructureFlagsKHR value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & BuildAccelerationStructureFlagBitsKHR::eAllowUpdate)
-    result += "AllowUpdate | ";
-  if (value & BuildAccelerationStructureFlagBitsKHR::eAllowCompaction)
-    result += "AllowCompaction | ";
-  if (value & BuildAccelerationStructureFlagBitsKHR::ePreferFastTrace)
-    result += "PreferFastTrace | ";
-  if (value & BuildAccelerationStructureFlagBitsKHR::ePreferFastBuild)
-    result += "PreferFastBuild | ";
-  if (value & BuildAccelerationStructureFlagBitsKHR::eLowMemory)
-    result += "LowMemory | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-using ColorComponentFlags = Flags<ColorComponentFlagBits>;
-
-template <> struct FlagTraits<ColorComponentFlagBits> {
-  enum : VkFlags {
-    allFlags = VkFlags(ColorComponentFlagBits::eR) |
-               VkFlags(ColorComponentFlagBits::eG) |
-               VkFlags(ColorComponentFlagBits::eB) |
-               VkFlags(ColorComponentFlagBits::eA)
-  };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ColorComponentFlags
-operator|(ColorComponentFlagBits bit0,
-          ColorComponentFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return ColorComponentFlags(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ColorComponentFlags
-operator&(ColorComponentFlagBits bit0,
-          ColorComponentFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return ColorComponentFlags(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ColorComponentFlags
-operator^(ColorComponentFlagBits bit0,
-          ColorComponentFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return ColorComponentFlags(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ColorComponentFlags
-operator~(ColorComponentFlagBits bits) VULKAN_HPP_NOEXCEPT {
-  return ~(ColorComponentFlags(bits));
-}
-
-VULKAN_HPP_INLINE std::string to_string(ColorComponentFlags value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & ColorComponentFlagBits::eR)
-    result += "R | ";
-  if (value & ColorComponentFlagBits::eG)
-    result += "G | ";
-  if (value & ColorComponentFlagBits::eB)
-    result += "B | ";
-  if (value & ColorComponentFlagBits::eA)
-    result += "A | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-using CommandBufferResetFlags = Flags<CommandBufferResetFlagBits>;
-
-template <> struct FlagTraits<CommandBufferResetFlagBits> {
-  enum : VkFlags {
-    allFlags = VkFlags(CommandBufferResetFlagBits::eReleaseResources)
-  };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CommandBufferResetFlags
-operator|(CommandBufferResetFlagBits bit0,
-          CommandBufferResetFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return CommandBufferResetFlags(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CommandBufferResetFlags
-operator&(CommandBufferResetFlagBits bit0,
-          CommandBufferResetFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return CommandBufferResetFlags(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CommandBufferResetFlags
-operator^(CommandBufferResetFlagBits bit0,
-          CommandBufferResetFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return CommandBufferResetFlags(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CommandBufferResetFlags
-operator~(CommandBufferResetFlagBits bits) VULKAN_HPP_NOEXCEPT {
-  return ~(CommandBufferResetFlags(bits));
-}
-
-VULKAN_HPP_INLINE std::string to_string(CommandBufferResetFlags value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & CommandBufferResetFlagBits::eReleaseResources)
-    result += "ReleaseResources | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-using CommandBufferUsageFlags = Flags<CommandBufferUsageFlagBits>;
-
-template <> struct FlagTraits<CommandBufferUsageFlagBits> {
-  enum : VkFlags {
-    allFlags = VkFlags(CommandBufferUsageFlagBits::eOneTimeSubmit) |
-               VkFlags(CommandBufferUsageFlagBits::eRenderPassContinue) |
-               VkFlags(CommandBufferUsageFlagBits::eSimultaneousUse)
-  };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CommandBufferUsageFlags
-operator|(CommandBufferUsageFlagBits bit0,
-          CommandBufferUsageFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return CommandBufferUsageFlags(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CommandBufferUsageFlags
-operator&(CommandBufferUsageFlagBits bit0,
-          CommandBufferUsageFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return CommandBufferUsageFlags(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CommandBufferUsageFlags
-operator^(CommandBufferUsageFlagBits bit0,
-          CommandBufferUsageFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return CommandBufferUsageFlags(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CommandBufferUsageFlags
-operator~(CommandBufferUsageFlagBits bits) VULKAN_HPP_NOEXCEPT {
-  return ~(CommandBufferUsageFlags(bits));
-}
-
-VULKAN_HPP_INLINE std::string to_string(CommandBufferUsageFlags value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & CommandBufferUsageFlagBits::eOneTimeSubmit)
-    result += "OneTimeSubmit | ";
-  if (value & CommandBufferUsageFlagBits::eRenderPassContinue)
-    result += "RenderPassContinue | ";
-  if (value & CommandBufferUsageFlagBits::eSimultaneousUse)
-    result += "SimultaneousUse | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-using CommandPoolCreateFlags = Flags<CommandPoolCreateFlagBits>;
-
-template <> struct FlagTraits<CommandPoolCreateFlagBits> {
-  enum : VkFlags {
-    allFlags = VkFlags(CommandPoolCreateFlagBits::eTransient) |
-               VkFlags(CommandPoolCreateFlagBits::eResetCommandBuffer) |
-               VkFlags(CommandPoolCreateFlagBits::eProtected)
-  };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CommandPoolCreateFlags
-operator|(CommandPoolCreateFlagBits bit0,
-          CommandPoolCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return CommandPoolCreateFlags(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CommandPoolCreateFlags
-operator&(CommandPoolCreateFlagBits bit0,
-          CommandPoolCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return CommandPoolCreateFlags(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CommandPoolCreateFlags
-operator^(CommandPoolCreateFlagBits bit0,
-          CommandPoolCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return CommandPoolCreateFlags(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CommandPoolCreateFlags
-operator~(CommandPoolCreateFlagBits bits) VULKAN_HPP_NOEXCEPT {
-  return ~(CommandPoolCreateFlags(bits));
-}
-
-VULKAN_HPP_INLINE std::string to_string(CommandPoolCreateFlags value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & CommandPoolCreateFlagBits::eTransient)
-    result += "Transient | ";
-  if (value & CommandPoolCreateFlagBits::eResetCommandBuffer)
-    result += "ResetCommandBuffer | ";
-  if (value & CommandPoolCreateFlagBits::eProtected)
-    result += "Protected | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-using CommandPoolResetFlags = Flags<CommandPoolResetFlagBits>;
-
-template <> struct FlagTraits<CommandPoolResetFlagBits> {
-  enum : VkFlags {
-    allFlags = VkFlags(CommandPoolResetFlagBits::eReleaseResources)
-  };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CommandPoolResetFlags
-operator|(CommandPoolResetFlagBits bit0,
-          CommandPoolResetFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return CommandPoolResetFlags(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CommandPoolResetFlags
-operator&(CommandPoolResetFlagBits bit0,
-          CommandPoolResetFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return CommandPoolResetFlags(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CommandPoolResetFlags
-operator^(CommandPoolResetFlagBits bit0,
-          CommandPoolResetFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return CommandPoolResetFlags(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CommandPoolResetFlags
-operator~(CommandPoolResetFlagBits bits) VULKAN_HPP_NOEXCEPT {
-  return ~(CommandPoolResetFlags(bits));
-}
-
-VULKAN_HPP_INLINE std::string to_string(CommandPoolResetFlags value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & CommandPoolResetFlagBits::eReleaseResources)
-    result += "ReleaseResources | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-enum class CommandPoolTrimFlagBits : VkFlags {};
-
-VULKAN_HPP_INLINE std::string to_string(CommandPoolTrimFlagBits) {
-  return "(void)";
-}
-
-using CommandPoolTrimFlags = Flags<CommandPoolTrimFlagBits>;
-
-using CommandPoolTrimFlagsKHR = CommandPoolTrimFlags;
-
-VULKAN_HPP_INLINE std::string to_string(CommandPoolTrimFlags) { return "{}"; }
-
-using CompositeAlphaFlagsKHR = Flags<CompositeAlphaFlagBitsKHR>;
-
-template <> struct FlagTraits<CompositeAlphaFlagBitsKHR> {
-  enum : VkFlags {
-    allFlags = VkFlags(CompositeAlphaFlagBitsKHR::eOpaque) |
-               VkFlags(CompositeAlphaFlagBitsKHR::ePreMultiplied) |
-               VkFlags(CompositeAlphaFlagBitsKHR::ePostMultiplied) |
-               VkFlags(CompositeAlphaFlagBitsKHR::eInherit)
-  };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CompositeAlphaFlagsKHR
-operator|(CompositeAlphaFlagBitsKHR bit0,
-          CompositeAlphaFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
-  return CompositeAlphaFlagsKHR(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CompositeAlphaFlagsKHR
-operator&(CompositeAlphaFlagBitsKHR bit0,
-          CompositeAlphaFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
-  return CompositeAlphaFlagsKHR(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CompositeAlphaFlagsKHR
-operator^(CompositeAlphaFlagBitsKHR bit0,
-          CompositeAlphaFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
-  return CompositeAlphaFlagsKHR(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CompositeAlphaFlagsKHR
-operator~(CompositeAlphaFlagBitsKHR bits) VULKAN_HPP_NOEXCEPT {
-  return ~(CompositeAlphaFlagsKHR(bits));
-}
-
-VULKAN_HPP_INLINE std::string to_string(CompositeAlphaFlagsKHR value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & CompositeAlphaFlagBitsKHR::eOpaque)
-    result += "Opaque | ";
-  if (value & CompositeAlphaFlagBitsKHR::ePreMultiplied)
-    result += "PreMultiplied | ";
-  if (value & CompositeAlphaFlagBitsKHR::ePostMultiplied)
-    result += "PostMultiplied | ";
-  if (value & CompositeAlphaFlagBitsKHR::eInherit)
-    result += "Inherit | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-using ConditionalRenderingFlagsEXT = Flags<ConditionalRenderingFlagBitsEXT>;
-
-template <> struct FlagTraits<ConditionalRenderingFlagBitsEXT> {
-  enum : VkFlags {
-    allFlags = VkFlags(ConditionalRenderingFlagBitsEXT::eInverted)
-  };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ConditionalRenderingFlagsEXT
-operator|(ConditionalRenderingFlagBitsEXT bit0,
-          ConditionalRenderingFlagBitsEXT bit1) VULKAN_HPP_NOEXCEPT {
-  return ConditionalRenderingFlagsEXT(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ConditionalRenderingFlagsEXT
-operator&(ConditionalRenderingFlagBitsEXT bit0,
-          ConditionalRenderingFlagBitsEXT bit1) VULKAN_HPP_NOEXCEPT {
-  return ConditionalRenderingFlagsEXT(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ConditionalRenderingFlagsEXT
-operator^(ConditionalRenderingFlagBitsEXT bit0,
-          ConditionalRenderingFlagBitsEXT bit1) VULKAN_HPP_NOEXCEPT {
-  return ConditionalRenderingFlagsEXT(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ConditionalRenderingFlagsEXT
-operator~(ConditionalRenderingFlagBitsEXT bits) VULKAN_HPP_NOEXCEPT {
-  return ~(ConditionalRenderingFlagsEXT(bits));
-}
-
-VULKAN_HPP_INLINE std::string to_string(ConditionalRenderingFlagsEXT value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & ConditionalRenderingFlagBitsEXT::eInverted)
-    result += "Inverted | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-using CullModeFlags = Flags<CullModeFlagBits>;
-
-template <> struct FlagTraits<CullModeFlagBits> {
-  enum : VkFlags {
-    allFlags = VkFlags(CullModeFlagBits::eNone) |
-               VkFlags(CullModeFlagBits::eFront) |
-               VkFlags(CullModeFlagBits::eBack) |
-               VkFlags(CullModeFlagBits::eFrontAndBack)
-  };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CullModeFlags
-operator|(CullModeFlagBits bit0, CullModeFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return CullModeFlags(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CullModeFlags
-operator&(CullModeFlagBits bit0, CullModeFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return CullModeFlags(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CullModeFlags
-operator^(CullModeFlagBits bit0, CullModeFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return CullModeFlags(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CullModeFlags
-operator~(CullModeFlagBits bits) VULKAN_HPP_NOEXCEPT {
-  return ~(CullModeFlags(bits));
-}
-
-VULKAN_HPP_INLINE std::string to_string(CullModeFlags value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & CullModeFlagBits::eFront)
-    result += "Front | ";
-  if (value & CullModeFlagBits::eBack)
-    result += "Back | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-using DebugReportFlagsEXT = Flags<DebugReportFlagBitsEXT>;
-
-template <> struct FlagTraits<DebugReportFlagBitsEXT> {
-  enum : VkFlags {
-    allFlags = VkFlags(DebugReportFlagBitsEXT::eInformation) |
-               VkFlags(DebugReportFlagBitsEXT::eWarning) |
-               VkFlags(DebugReportFlagBitsEXT::ePerformanceWarning) |
-               VkFlags(DebugReportFlagBitsEXT::eError) |
-               VkFlags(DebugReportFlagBitsEXT::eDebug)
-  };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DebugReportFlagsEXT
-operator|(DebugReportFlagBitsEXT bit0,
-          DebugReportFlagBitsEXT bit1) VULKAN_HPP_NOEXCEPT {
-  return DebugReportFlagsEXT(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DebugReportFlagsEXT
-operator&(DebugReportFlagBitsEXT bit0,
-          DebugReportFlagBitsEXT bit1) VULKAN_HPP_NOEXCEPT {
-  return DebugReportFlagsEXT(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DebugReportFlagsEXT
-operator^(DebugReportFlagBitsEXT bit0,
-          DebugReportFlagBitsEXT bit1) VULKAN_HPP_NOEXCEPT {
-  return DebugReportFlagsEXT(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DebugReportFlagsEXT
-operator~(DebugReportFlagBitsEXT bits) VULKAN_HPP_NOEXCEPT {
-  return ~(DebugReportFlagsEXT(bits));
-}
-
-VULKAN_HPP_INLINE std::string to_string(DebugReportFlagsEXT value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & DebugReportFlagBitsEXT::eInformation)
-    result += "Information | ";
-  if (value & DebugReportFlagBitsEXT::eWarning)
-    result += "Warning | ";
-  if (value & DebugReportFlagBitsEXT::ePerformanceWarning)
-    result += "PerformanceWarning | ";
-  if (value & DebugReportFlagBitsEXT::eError)
-    result += "Error | ";
-  if (value & DebugReportFlagBitsEXT::eDebug)
-    result += "Debug | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-using DebugUtilsMessageSeverityFlagsEXT =
-    Flags<DebugUtilsMessageSeverityFlagBitsEXT>;
-
-template <> struct FlagTraits<DebugUtilsMessageSeverityFlagBitsEXT> {
-  enum : VkFlags {
-    allFlags = VkFlags(DebugUtilsMessageSeverityFlagBitsEXT::eVerbose) |
-               VkFlags(DebugUtilsMessageSeverityFlagBitsEXT::eInfo) |
-               VkFlags(DebugUtilsMessageSeverityFlagBitsEXT::eWarning) |
-               VkFlags(DebugUtilsMessageSeverityFlagBitsEXT::eError)
-  };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DebugUtilsMessageSeverityFlagsEXT
-operator|(DebugUtilsMessageSeverityFlagBitsEXT bit0,
-          DebugUtilsMessageSeverityFlagBitsEXT bit1) VULKAN_HPP_NOEXCEPT {
-  return DebugUtilsMessageSeverityFlagsEXT(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DebugUtilsMessageSeverityFlagsEXT
-operator&(DebugUtilsMessageSeverityFlagBitsEXT bit0,
-          DebugUtilsMessageSeverityFlagBitsEXT bit1) VULKAN_HPP_NOEXCEPT {
-  return DebugUtilsMessageSeverityFlagsEXT(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DebugUtilsMessageSeverityFlagsEXT
-operator^(DebugUtilsMessageSeverityFlagBitsEXT bit0,
-          DebugUtilsMessageSeverityFlagBitsEXT bit1) VULKAN_HPP_NOEXCEPT {
-  return DebugUtilsMessageSeverityFlagsEXT(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DebugUtilsMessageSeverityFlagsEXT
-operator~(DebugUtilsMessageSeverityFlagBitsEXT bits) VULKAN_HPP_NOEXCEPT {
-  return ~(DebugUtilsMessageSeverityFlagsEXT(bits));
-}
-
-VULKAN_HPP_INLINE std::string
-to_string(DebugUtilsMessageSeverityFlagsEXT value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & DebugUtilsMessageSeverityFlagBitsEXT::eVerbose)
-    result += "Verbose | ";
-  if (value & DebugUtilsMessageSeverityFlagBitsEXT::eInfo)
-    result += "Info | ";
-  if (value & DebugUtilsMessageSeverityFlagBitsEXT::eWarning)
-    result += "Warning | ";
-  if (value & DebugUtilsMessageSeverityFlagBitsEXT::eError)
-    result += "Error | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-using DebugUtilsMessageTypeFlagsEXT = Flags<DebugUtilsMessageTypeFlagBitsEXT>;
-
-template <> struct FlagTraits<DebugUtilsMessageTypeFlagBitsEXT> {
-  enum : VkFlags {
-    allFlags = VkFlags(DebugUtilsMessageTypeFlagBitsEXT::eGeneral) |
-               VkFlags(DebugUtilsMessageTypeFlagBitsEXT::eValidation) |
-               VkFlags(DebugUtilsMessageTypeFlagBitsEXT::ePerformance)
-  };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DebugUtilsMessageTypeFlagsEXT
-operator|(DebugUtilsMessageTypeFlagBitsEXT bit0,
-          DebugUtilsMessageTypeFlagBitsEXT bit1) VULKAN_HPP_NOEXCEPT {
-  return DebugUtilsMessageTypeFlagsEXT(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DebugUtilsMessageTypeFlagsEXT
-operator&(DebugUtilsMessageTypeFlagBitsEXT bit0,
-          DebugUtilsMessageTypeFlagBitsEXT bit1) VULKAN_HPP_NOEXCEPT {
-  return DebugUtilsMessageTypeFlagsEXT(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DebugUtilsMessageTypeFlagsEXT
-operator^(DebugUtilsMessageTypeFlagBitsEXT bit0,
-          DebugUtilsMessageTypeFlagBitsEXT bit1) VULKAN_HPP_NOEXCEPT {
-  return DebugUtilsMessageTypeFlagsEXT(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DebugUtilsMessageTypeFlagsEXT
-operator~(DebugUtilsMessageTypeFlagBitsEXT bits) VULKAN_HPP_NOEXCEPT {
-  return ~(DebugUtilsMessageTypeFlagsEXT(bits));
-}
-
-VULKAN_HPP_INLINE std::string to_string(DebugUtilsMessageTypeFlagsEXT value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & DebugUtilsMessageTypeFlagBitsEXT::eGeneral)
-    result += "General | ";
-  if (value & DebugUtilsMessageTypeFlagBitsEXT::eValidation)
-    result += "Validation | ";
-  if (value & DebugUtilsMessageTypeFlagBitsEXT::ePerformance)
-    result += "Performance | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-enum class DebugUtilsMessengerCallbackDataFlagBitsEXT : VkFlags {};
-
-VULKAN_HPP_INLINE std::string
-to_string(DebugUtilsMessengerCallbackDataFlagBitsEXT) {
-  return "(void)";
-}
-
-using DebugUtilsMessengerCallbackDataFlagsEXT =
-    Flags<DebugUtilsMessengerCallbackDataFlagBitsEXT>;
-
-VULKAN_HPP_INLINE std::string
-to_string(DebugUtilsMessengerCallbackDataFlagsEXT) {
-
-  return "{}";
-}
-
-enum class DebugUtilsMessengerCreateFlagBitsEXT : VkFlags {};
-
-VULKAN_HPP_INLINE std::string to_string(DebugUtilsMessengerCreateFlagBitsEXT) {
-  return "(void)";
-}
-
-using DebugUtilsMessengerCreateFlagsEXT =
-    Flags<DebugUtilsMessengerCreateFlagBitsEXT>;
-
-VULKAN_HPP_INLINE std::string to_string(DebugUtilsMessengerCreateFlagsEXT) {
-
-  return "{}";
-}
-
-using DependencyFlags = Flags<DependencyFlagBits>;
-
-template <> struct FlagTraits<DependencyFlagBits> {
-  enum : VkFlags {
-    allFlags = VkFlags(DependencyFlagBits::eByRegion) |
-               VkFlags(DependencyFlagBits::eDeviceGroup) |
-               VkFlags(DependencyFlagBits::eViewLocal)
-  };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DependencyFlags operator|(
-    DependencyFlagBits bit0, DependencyFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return DependencyFlags(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DependencyFlags operator&(
-    DependencyFlagBits bit0, DependencyFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return DependencyFlags(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DependencyFlags operator^(
-    DependencyFlagBits bit0, DependencyFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return DependencyFlags(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DependencyFlags
-operator~(DependencyFlagBits bits) VULKAN_HPP_NOEXCEPT {
-  return ~(DependencyFlags(bits));
-}
-
-VULKAN_HPP_INLINE std::string to_string(DependencyFlags value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & DependencyFlagBits::eByRegion)
-    result += "ByRegion | ";
-  if (value & DependencyFlagBits::eDeviceGroup)
-    result += "DeviceGroup | ";
-  if (value & DependencyFlagBits::eViewLocal)
-    result += "ViewLocal | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-using DescriptorBindingFlags = Flags<DescriptorBindingFlagBits>;
-
-template <> struct FlagTraits<DescriptorBindingFlagBits> {
-  enum : VkFlags {
-    allFlags = VkFlags(DescriptorBindingFlagBits::eUpdateAfterBind) |
-               VkFlags(DescriptorBindingFlagBits::eUpdateUnusedWhilePending) |
-               VkFlags(DescriptorBindingFlagBits::ePartiallyBound) |
-               VkFlags(DescriptorBindingFlagBits::eVariableDescriptorCount)
-  };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DescriptorBindingFlags
-operator|(DescriptorBindingFlagBits bit0,
-          DescriptorBindingFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return DescriptorBindingFlags(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DescriptorBindingFlags
-operator&(DescriptorBindingFlagBits bit0,
-          DescriptorBindingFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return DescriptorBindingFlags(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DescriptorBindingFlags
-operator^(DescriptorBindingFlagBits bit0,
-          DescriptorBindingFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return DescriptorBindingFlags(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DescriptorBindingFlags
-operator~(DescriptorBindingFlagBits bits) VULKAN_HPP_NOEXCEPT {
-  return ~(DescriptorBindingFlags(bits));
-}
-
-using DescriptorBindingFlagsEXT = DescriptorBindingFlags;
-
-VULKAN_HPP_INLINE std::string to_string(DescriptorBindingFlags value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & DescriptorBindingFlagBits::eUpdateAfterBind)
-    result += "UpdateAfterBind | ";
-  if (value & DescriptorBindingFlagBits::eUpdateUnusedWhilePending)
-    result += "UpdateUnusedWhilePending | ";
-  if (value & DescriptorBindingFlagBits::ePartiallyBound)
-    result += "PartiallyBound | ";
-  if (value & DescriptorBindingFlagBits::eVariableDescriptorCount)
-    result += "VariableDescriptorCount | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-using DescriptorPoolCreateFlags = Flags<DescriptorPoolCreateFlagBits>;
-
-template <> struct FlagTraits<DescriptorPoolCreateFlagBits> {
-  enum : VkFlags {
-    allFlags = VkFlags(DescriptorPoolCreateFlagBits::eFreeDescriptorSet) |
-               VkFlags(DescriptorPoolCreateFlagBits::eUpdateAfterBind) |
-               VkFlags(DescriptorPoolCreateFlagBits::eHostOnlyVALVE)
-  };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DescriptorPoolCreateFlags
-operator|(DescriptorPoolCreateFlagBits bit0,
-          DescriptorPoolCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return DescriptorPoolCreateFlags(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DescriptorPoolCreateFlags
-operator&(DescriptorPoolCreateFlagBits bit0,
-          DescriptorPoolCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return DescriptorPoolCreateFlags(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DescriptorPoolCreateFlags
-operator^(DescriptorPoolCreateFlagBits bit0,
-          DescriptorPoolCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return DescriptorPoolCreateFlags(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DescriptorPoolCreateFlags
-operator~(DescriptorPoolCreateFlagBits bits) VULKAN_HPP_NOEXCEPT {
-  return ~(DescriptorPoolCreateFlags(bits));
-}
-
-VULKAN_HPP_INLINE std::string to_string(DescriptorPoolCreateFlags value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & DescriptorPoolCreateFlagBits::eFreeDescriptorSet)
-    result += "FreeDescriptorSet | ";
-  if (value & DescriptorPoolCreateFlagBits::eUpdateAfterBind)
-    result += "UpdateAfterBind | ";
-  if (value & DescriptorPoolCreateFlagBits::eHostOnlyVALVE)
-    result += "HostOnlyVALVE | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-enum class DescriptorPoolResetFlagBits : VkFlags {};
-
-VULKAN_HPP_INLINE std::string to_string(DescriptorPoolResetFlagBits) {
-  return "(void)";
-}
-
-using DescriptorPoolResetFlags = Flags<DescriptorPoolResetFlagBits>;
-
-VULKAN_HPP_INLINE std::string to_string(DescriptorPoolResetFlags) {
-
-  return "{}";
-}
-
-using DescriptorSetLayoutCreateFlags = Flags<DescriptorSetLayoutCreateFlagBits>;
-
-template <> struct FlagTraits<DescriptorSetLayoutCreateFlagBits> {
-  enum : VkFlags {
-    allFlags =
-        VkFlags(DescriptorSetLayoutCreateFlagBits::eUpdateAfterBindPool) |
-        VkFlags(DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR) |
-        VkFlags(DescriptorSetLayoutCreateFlagBits::eHostOnlyPoolVALVE)
-  };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DescriptorSetLayoutCreateFlags
-operator|(DescriptorSetLayoutCreateFlagBits bit0,
-          DescriptorSetLayoutCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return DescriptorSetLayoutCreateFlags(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DescriptorSetLayoutCreateFlags
-operator&(DescriptorSetLayoutCreateFlagBits bit0,
-          DescriptorSetLayoutCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return DescriptorSetLayoutCreateFlags(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DescriptorSetLayoutCreateFlags
-operator^(DescriptorSetLayoutCreateFlagBits bit0,
-          DescriptorSetLayoutCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return DescriptorSetLayoutCreateFlags(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DescriptorSetLayoutCreateFlags
-operator~(DescriptorSetLayoutCreateFlagBits bits) VULKAN_HPP_NOEXCEPT {
-  return ~(DescriptorSetLayoutCreateFlags(bits));
-}
-
-VULKAN_HPP_INLINE std::string to_string(DescriptorSetLayoutCreateFlags value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & DescriptorSetLayoutCreateFlagBits::eUpdateAfterBindPool)
-    result += "UpdateAfterBindPool | ";
-  if (value & DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR)
-    result += "PushDescriptorKHR | ";
-  if (value & DescriptorSetLayoutCreateFlagBits::eHostOnlyPoolVALVE)
-    result += "HostOnlyPoolVALVE | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-enum class DescriptorUpdateTemplateCreateFlagBits : VkFlags {};
-
-VULKAN_HPP_INLINE std::string
-to_string(DescriptorUpdateTemplateCreateFlagBits) {
-  return "(void)";
-}
-
-using DescriptorUpdateTemplateCreateFlags =
-    Flags<DescriptorUpdateTemplateCreateFlagBits>;
-
-using DescriptorUpdateTemplateCreateFlagsKHR =
-    DescriptorUpdateTemplateCreateFlags;
-
-VULKAN_HPP_INLINE std::string to_string(DescriptorUpdateTemplateCreateFlags) {
-
-  return "{}";
-}
-
-using DeviceCreateFlags = Flags<DeviceCreateFlagBits>;
-
-VULKAN_HPP_INLINE std::string to_string(DeviceCreateFlags) { return "{}"; }
-
-using DeviceDiagnosticsConfigFlagsNV = Flags<DeviceDiagnosticsConfigFlagBitsNV>;
-
-template <> struct FlagTraits<DeviceDiagnosticsConfigFlagBitsNV> {
-  enum : VkFlags {
-    allFlags =
-        VkFlags(DeviceDiagnosticsConfigFlagBitsNV::eEnableShaderDebugInfo) |
-        VkFlags(DeviceDiagnosticsConfigFlagBitsNV::eEnableResourceTracking) |
-        VkFlags(DeviceDiagnosticsConfigFlagBitsNV::eEnableAutomaticCheckpoints)
-  };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DeviceDiagnosticsConfigFlagsNV
-operator|(DeviceDiagnosticsConfigFlagBitsNV bit0,
-          DeviceDiagnosticsConfigFlagBitsNV bit1) VULKAN_HPP_NOEXCEPT {
-  return DeviceDiagnosticsConfigFlagsNV(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DeviceDiagnosticsConfigFlagsNV
-operator&(DeviceDiagnosticsConfigFlagBitsNV bit0,
-          DeviceDiagnosticsConfigFlagBitsNV bit1) VULKAN_HPP_NOEXCEPT {
-  return DeviceDiagnosticsConfigFlagsNV(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DeviceDiagnosticsConfigFlagsNV
-operator^(DeviceDiagnosticsConfigFlagBitsNV bit0,
-          DeviceDiagnosticsConfigFlagBitsNV bit1) VULKAN_HPP_NOEXCEPT {
-  return DeviceDiagnosticsConfigFlagsNV(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DeviceDiagnosticsConfigFlagsNV
-operator~(DeviceDiagnosticsConfigFlagBitsNV bits) VULKAN_HPP_NOEXCEPT {
-  return ~(DeviceDiagnosticsConfigFlagsNV(bits));
-}
-
-VULKAN_HPP_INLINE std::string to_string(DeviceDiagnosticsConfigFlagsNV value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & DeviceDiagnosticsConfigFlagBitsNV::eEnableShaderDebugInfo)
-    result += "EnableShaderDebugInfo | ";
-  if (value & DeviceDiagnosticsConfigFlagBitsNV::eEnableResourceTracking)
-    result += "EnableResourceTracking | ";
-  if (value & DeviceDiagnosticsConfigFlagBitsNV::eEnableAutomaticCheckpoints)
-    result += "EnableAutomaticCheckpoints | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-using DeviceGroupPresentModeFlagsKHR = Flags<DeviceGroupPresentModeFlagBitsKHR>;
-
-template <> struct FlagTraits<DeviceGroupPresentModeFlagBitsKHR> {
-  enum : VkFlags {
-    allFlags = VkFlags(DeviceGroupPresentModeFlagBitsKHR::eLocal) |
-               VkFlags(DeviceGroupPresentModeFlagBitsKHR::eRemote) |
-               VkFlags(DeviceGroupPresentModeFlagBitsKHR::eSum) |
-               VkFlags(DeviceGroupPresentModeFlagBitsKHR::eLocalMultiDevice)
-  };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DeviceGroupPresentModeFlagsKHR
-operator|(DeviceGroupPresentModeFlagBitsKHR bit0,
-          DeviceGroupPresentModeFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
-  return DeviceGroupPresentModeFlagsKHR(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DeviceGroupPresentModeFlagsKHR
-operator&(DeviceGroupPresentModeFlagBitsKHR bit0,
-          DeviceGroupPresentModeFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
-  return DeviceGroupPresentModeFlagsKHR(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DeviceGroupPresentModeFlagsKHR
-operator^(DeviceGroupPresentModeFlagBitsKHR bit0,
-          DeviceGroupPresentModeFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
-  return DeviceGroupPresentModeFlagsKHR(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DeviceGroupPresentModeFlagsKHR
-operator~(DeviceGroupPresentModeFlagBitsKHR bits) VULKAN_HPP_NOEXCEPT {
-  return ~(DeviceGroupPresentModeFlagsKHR(bits));
-}
-
-VULKAN_HPP_INLINE std::string to_string(DeviceGroupPresentModeFlagsKHR value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & DeviceGroupPresentModeFlagBitsKHR::eLocal)
-    result += "Local | ";
-  if (value & DeviceGroupPresentModeFlagBitsKHR::eRemote)
-    result += "Remote | ";
-  if (value & DeviceGroupPresentModeFlagBitsKHR::eSum)
-    result += "Sum | ";
-  if (value & DeviceGroupPresentModeFlagBitsKHR::eLocalMultiDevice)
-    result += "LocalMultiDevice | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-enum class DeviceMemoryReportFlagBitsEXT : VkFlags {};
-
-VULKAN_HPP_INLINE std::string to_string(DeviceMemoryReportFlagBitsEXT) {
-  return "(void)";
-}
-
-using DeviceMemoryReportFlagsEXT = Flags<DeviceMemoryReportFlagBitsEXT>;
-
-VULKAN_HPP_INLINE std::string to_string(DeviceMemoryReportFlagsEXT) {
-
-  return "{}";
-}
-
-using DeviceQueueCreateFlags = Flags<DeviceQueueCreateFlagBits>;
-
-template <> struct FlagTraits<DeviceQueueCreateFlagBits> {
-  enum : VkFlags { allFlags = VkFlags(DeviceQueueCreateFlagBits::eProtected) };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DeviceQueueCreateFlags
-operator|(DeviceQueueCreateFlagBits bit0,
-          DeviceQueueCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return DeviceQueueCreateFlags(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DeviceQueueCreateFlags
-operator&(DeviceQueueCreateFlagBits bit0,
-          DeviceQueueCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return DeviceQueueCreateFlags(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DeviceQueueCreateFlags
-operator^(DeviceQueueCreateFlagBits bit0,
-          DeviceQueueCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return DeviceQueueCreateFlags(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DeviceQueueCreateFlags
-operator~(DeviceQueueCreateFlagBits bits) VULKAN_HPP_NOEXCEPT {
-  return ~(DeviceQueueCreateFlags(bits));
-}
-
-VULKAN_HPP_INLINE std::string to_string(DeviceQueueCreateFlags value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & DeviceQueueCreateFlagBits::eProtected)
-    result += "Protected | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
-enum class DirectFBSurfaceCreateFlagBitsEXT : VkFlags {};
-
-VULKAN_HPP_INLINE std::string to_string(DirectFBSurfaceCreateFlagBitsEXT) {
-  return "(void)";
-}
-
-using DirectFBSurfaceCreateFlagsEXT = Flags<DirectFBSurfaceCreateFlagBitsEXT>;
-
-VULKAN_HPP_INLINE std::string to_string(DirectFBSurfaceCreateFlagsEXT) {
-
-  return "{}";
-}
-#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
-
-enum class DisplayModeCreateFlagBitsKHR : VkFlags {};
-
-VULKAN_HPP_INLINE std::string to_string(DisplayModeCreateFlagBitsKHR) {
-  return "(void)";
-}
-
-using DisplayModeCreateFlagsKHR = Flags<DisplayModeCreateFlagBitsKHR>;
-
-VULKAN_HPP_INLINE std::string to_string(DisplayModeCreateFlagsKHR) {
-
-  return "{}";
-}
-
-using DisplayPlaneAlphaFlagsKHR = Flags<DisplayPlaneAlphaFlagBitsKHR>;
-
-template <> struct FlagTraits<DisplayPlaneAlphaFlagBitsKHR> {
-  enum : VkFlags {
-    allFlags = VkFlags(DisplayPlaneAlphaFlagBitsKHR::eOpaque) |
-               VkFlags(DisplayPlaneAlphaFlagBitsKHR::eGlobal) |
-               VkFlags(DisplayPlaneAlphaFlagBitsKHR::ePerPixel) |
-               VkFlags(DisplayPlaneAlphaFlagBitsKHR::ePerPixelPremultiplied)
-  };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DisplayPlaneAlphaFlagsKHR
-operator|(DisplayPlaneAlphaFlagBitsKHR bit0,
-          DisplayPlaneAlphaFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
-  return DisplayPlaneAlphaFlagsKHR(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DisplayPlaneAlphaFlagsKHR
-operator&(DisplayPlaneAlphaFlagBitsKHR bit0,
-          DisplayPlaneAlphaFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
-  return DisplayPlaneAlphaFlagsKHR(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DisplayPlaneAlphaFlagsKHR
-operator^(DisplayPlaneAlphaFlagBitsKHR bit0,
-          DisplayPlaneAlphaFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
-  return DisplayPlaneAlphaFlagsKHR(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DisplayPlaneAlphaFlagsKHR
-operator~(DisplayPlaneAlphaFlagBitsKHR bits) VULKAN_HPP_NOEXCEPT {
-  return ~(DisplayPlaneAlphaFlagsKHR(bits));
-}
-
-VULKAN_HPP_INLINE std::string to_string(DisplayPlaneAlphaFlagsKHR value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & DisplayPlaneAlphaFlagBitsKHR::eOpaque)
-    result += "Opaque | ";
-  if (value & DisplayPlaneAlphaFlagBitsKHR::eGlobal)
-    result += "Global | ";
-  if (value & DisplayPlaneAlphaFlagBitsKHR::ePerPixel)
-    result += "PerPixel | ";
-  if (value & DisplayPlaneAlphaFlagBitsKHR::ePerPixelPremultiplied)
-    result += "PerPixelPremultiplied | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-enum class DisplaySurfaceCreateFlagBitsKHR : VkFlags {};
-
-VULKAN_HPP_INLINE std::string to_string(DisplaySurfaceCreateFlagBitsKHR) {
-  return "(void)";
-}
-
-using DisplaySurfaceCreateFlagsKHR = Flags<DisplaySurfaceCreateFlagBitsKHR>;
-
-VULKAN_HPP_INLINE std::string to_string(DisplaySurfaceCreateFlagsKHR) {
-
-  return "{}";
-}
-
-using EventCreateFlags = Flags<EventCreateFlagBits>;
-
-template <> struct FlagTraits<EventCreateFlagBits> {
-  enum : VkFlags { allFlags = VkFlags(EventCreateFlagBits::eDeviceOnlyKHR) };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR EventCreateFlags operator|(
-    EventCreateFlagBits bit0, EventCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return EventCreateFlags(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR EventCreateFlags operator&(
-    EventCreateFlagBits bit0, EventCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return EventCreateFlags(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR EventCreateFlags operator^(
-    EventCreateFlagBits bit0, EventCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return EventCreateFlags(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR EventCreateFlags
-operator~(EventCreateFlagBits bits) VULKAN_HPP_NOEXCEPT {
-  return ~(EventCreateFlags(bits));
-}
-
-VULKAN_HPP_INLINE std::string to_string(EventCreateFlags value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & EventCreateFlagBits::eDeviceOnlyKHR)
-    result += "DeviceOnlyKHR | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-using ExternalFenceFeatureFlags = Flags<ExternalFenceFeatureFlagBits>;
-
-template <> struct FlagTraits<ExternalFenceFeatureFlagBits> {
-  enum : VkFlags {
-    allFlags = VkFlags(ExternalFenceFeatureFlagBits::eExportable) |
-               VkFlags(ExternalFenceFeatureFlagBits::eImportable)
-  };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalFenceFeatureFlags
-operator|(ExternalFenceFeatureFlagBits bit0,
-          ExternalFenceFeatureFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return ExternalFenceFeatureFlags(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalFenceFeatureFlags
-operator&(ExternalFenceFeatureFlagBits bit0,
-          ExternalFenceFeatureFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return ExternalFenceFeatureFlags(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalFenceFeatureFlags
-operator^(ExternalFenceFeatureFlagBits bit0,
-          ExternalFenceFeatureFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return ExternalFenceFeatureFlags(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalFenceFeatureFlags
-operator~(ExternalFenceFeatureFlagBits bits) VULKAN_HPP_NOEXCEPT {
-  return ~(ExternalFenceFeatureFlags(bits));
-}
-
-using ExternalFenceFeatureFlagsKHR = ExternalFenceFeatureFlags;
-
-VULKAN_HPP_INLINE std::string to_string(ExternalFenceFeatureFlags value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & ExternalFenceFeatureFlagBits::eExportable)
-    result += "Exportable | ";
-  if (value & ExternalFenceFeatureFlagBits::eImportable)
-    result += "Importable | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-using ExternalFenceHandleTypeFlags = Flags<ExternalFenceHandleTypeFlagBits>;
-
-template <> struct FlagTraits<ExternalFenceHandleTypeFlagBits> {
-  enum : VkFlags {
-    allFlags = VkFlags(ExternalFenceHandleTypeFlagBits::eOpaqueFd) |
-               VkFlags(ExternalFenceHandleTypeFlagBits::eOpaqueWin32) |
-               VkFlags(ExternalFenceHandleTypeFlagBits::eOpaqueWin32Kmt) |
-               VkFlags(ExternalFenceHandleTypeFlagBits::eSyncFd)
-  };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalFenceHandleTypeFlags
-operator|(ExternalFenceHandleTypeFlagBits bit0,
-          ExternalFenceHandleTypeFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return ExternalFenceHandleTypeFlags(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalFenceHandleTypeFlags
-operator&(ExternalFenceHandleTypeFlagBits bit0,
-          ExternalFenceHandleTypeFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return ExternalFenceHandleTypeFlags(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalFenceHandleTypeFlags
-operator^(ExternalFenceHandleTypeFlagBits bit0,
-          ExternalFenceHandleTypeFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return ExternalFenceHandleTypeFlags(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalFenceHandleTypeFlags
-operator~(ExternalFenceHandleTypeFlagBits bits) VULKAN_HPP_NOEXCEPT {
-  return ~(ExternalFenceHandleTypeFlags(bits));
-}
-
-using ExternalFenceHandleTypeFlagsKHR = ExternalFenceHandleTypeFlags;
-
-VULKAN_HPP_INLINE std::string to_string(ExternalFenceHandleTypeFlags value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & ExternalFenceHandleTypeFlagBits::eOpaqueFd)
-    result += "OpaqueFd | ";
-  if (value & ExternalFenceHandleTypeFlagBits::eOpaqueWin32)
-    result += "OpaqueWin32 | ";
-  if (value & ExternalFenceHandleTypeFlagBits::eOpaqueWin32Kmt)
-    result += "OpaqueWin32Kmt | ";
-  if (value & ExternalFenceHandleTypeFlagBits::eSyncFd)
-    result += "SyncFd | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-using ExternalMemoryFeatureFlags = Flags<ExternalMemoryFeatureFlagBits>;
-
-template <> struct FlagTraits<ExternalMemoryFeatureFlagBits> {
-  enum : VkFlags {
-    allFlags = VkFlags(ExternalMemoryFeatureFlagBits::eDedicatedOnly) |
-               VkFlags(ExternalMemoryFeatureFlagBits::eExportable) |
-               VkFlags(ExternalMemoryFeatureFlagBits::eImportable)
-  };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalMemoryFeatureFlags
-operator|(ExternalMemoryFeatureFlagBits bit0,
-          ExternalMemoryFeatureFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return ExternalMemoryFeatureFlags(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalMemoryFeatureFlags
-operator&(ExternalMemoryFeatureFlagBits bit0,
-          ExternalMemoryFeatureFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return ExternalMemoryFeatureFlags(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalMemoryFeatureFlags
-operator^(ExternalMemoryFeatureFlagBits bit0,
-          ExternalMemoryFeatureFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return ExternalMemoryFeatureFlags(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalMemoryFeatureFlags
-operator~(ExternalMemoryFeatureFlagBits bits) VULKAN_HPP_NOEXCEPT {
-  return ~(ExternalMemoryFeatureFlags(bits));
-}
-
-using ExternalMemoryFeatureFlagsKHR = ExternalMemoryFeatureFlags;
-
-VULKAN_HPP_INLINE std::string to_string(ExternalMemoryFeatureFlags value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & ExternalMemoryFeatureFlagBits::eDedicatedOnly)
-    result += "DedicatedOnly | ";
-  if (value & ExternalMemoryFeatureFlagBits::eExportable)
-    result += "Exportable | ";
-  if (value & ExternalMemoryFeatureFlagBits::eImportable)
-    result += "Importable | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-using ExternalMemoryFeatureFlagsNV = Flags<ExternalMemoryFeatureFlagBitsNV>;
-
-template <> struct FlagTraits<ExternalMemoryFeatureFlagBitsNV> {
-  enum : VkFlags {
-    allFlags = VkFlags(ExternalMemoryFeatureFlagBitsNV::eDedicatedOnly) |
-               VkFlags(ExternalMemoryFeatureFlagBitsNV::eExportable) |
-               VkFlags(ExternalMemoryFeatureFlagBitsNV::eImportable)
-  };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalMemoryFeatureFlagsNV
-operator|(ExternalMemoryFeatureFlagBitsNV bit0,
-          ExternalMemoryFeatureFlagBitsNV bit1) VULKAN_HPP_NOEXCEPT {
-  return ExternalMemoryFeatureFlagsNV(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalMemoryFeatureFlagsNV
-operator&(ExternalMemoryFeatureFlagBitsNV bit0,
-          ExternalMemoryFeatureFlagBitsNV bit1) VULKAN_HPP_NOEXCEPT {
-  return ExternalMemoryFeatureFlagsNV(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalMemoryFeatureFlagsNV
-operator^(ExternalMemoryFeatureFlagBitsNV bit0,
-          ExternalMemoryFeatureFlagBitsNV bit1) VULKAN_HPP_NOEXCEPT {
-  return ExternalMemoryFeatureFlagsNV(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalMemoryFeatureFlagsNV
-operator~(ExternalMemoryFeatureFlagBitsNV bits) VULKAN_HPP_NOEXCEPT {
-  return ~(ExternalMemoryFeatureFlagsNV(bits));
-}
-
-VULKAN_HPP_INLINE std::string to_string(ExternalMemoryFeatureFlagsNV value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & ExternalMemoryFeatureFlagBitsNV::eDedicatedOnly)
-    result += "DedicatedOnly | ";
-  if (value & ExternalMemoryFeatureFlagBitsNV::eExportable)
-    result += "Exportable | ";
-  if (value & ExternalMemoryFeatureFlagBitsNV::eImportable)
-    result += "Importable | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-using ExternalMemoryHandleTypeFlags = Flags<ExternalMemoryHandleTypeFlagBits>;
-
-template <> struct FlagTraits<ExternalMemoryHandleTypeFlagBits> {
-  enum : VkFlags {
-    allFlags =
-        VkFlags(ExternalMemoryHandleTypeFlagBits::eOpaqueFd) |
-        VkFlags(ExternalMemoryHandleTypeFlagBits::eOpaqueWin32) |
-        VkFlags(ExternalMemoryHandleTypeFlagBits::eOpaqueWin32Kmt) |
-        VkFlags(ExternalMemoryHandleTypeFlagBits::eD3D11Texture) |
-        VkFlags(ExternalMemoryHandleTypeFlagBits::eD3D11TextureKmt) |
-        VkFlags(ExternalMemoryHandleTypeFlagBits::eD3D12Heap) |
-        VkFlags(ExternalMemoryHandleTypeFlagBits::eD3D12Resource) |
-        VkFlags(ExternalMemoryHandleTypeFlagBits::eDmaBufEXT)
-#if defined(VK_USE_PLATFORM_ANDROID_KHR)
-        |
-        VkFlags(ExternalMemoryHandleTypeFlagBits::eAndroidHardwareBufferANDROID)
-#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
-        | VkFlags(ExternalMemoryHandleTypeFlagBits::eHostAllocationEXT) |
-        VkFlags(ExternalMemoryHandleTypeFlagBits::eHostMappedForeignMemoryEXT)
-#if defined(VK_USE_PLATFORM_FUCHSIA)
-        | VkFlags(ExternalMemoryHandleTypeFlagBits::eZirconVmoFUCHSIA)
-#endif /*VK_USE_PLATFORM_FUCHSIA*/
-  };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalMemoryHandleTypeFlags
-operator|(ExternalMemoryHandleTypeFlagBits bit0,
-          ExternalMemoryHandleTypeFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return ExternalMemoryHandleTypeFlags(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalMemoryHandleTypeFlags
-operator&(ExternalMemoryHandleTypeFlagBits bit0,
-          ExternalMemoryHandleTypeFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return ExternalMemoryHandleTypeFlags(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalMemoryHandleTypeFlags
-operator^(ExternalMemoryHandleTypeFlagBits bit0,
-          ExternalMemoryHandleTypeFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return ExternalMemoryHandleTypeFlags(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalMemoryHandleTypeFlags
-operator~(ExternalMemoryHandleTypeFlagBits bits) VULKAN_HPP_NOEXCEPT {
-  return ~(ExternalMemoryHandleTypeFlags(bits));
-}
-
-using ExternalMemoryHandleTypeFlagsKHR = ExternalMemoryHandleTypeFlags;
-
-VULKAN_HPP_INLINE std::string to_string(ExternalMemoryHandleTypeFlags value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & ExternalMemoryHandleTypeFlagBits::eOpaqueFd)
-    result += "OpaqueFd | ";
-  if (value & ExternalMemoryHandleTypeFlagBits::eOpaqueWin32)
-    result += "OpaqueWin32 | ";
-  if (value & ExternalMemoryHandleTypeFlagBits::eOpaqueWin32Kmt)
-    result += "OpaqueWin32Kmt | ";
-  if (value & ExternalMemoryHandleTypeFlagBits::eD3D11Texture)
-    result += "D3D11Texture | ";
-  if (value & ExternalMemoryHandleTypeFlagBits::eD3D11TextureKmt)
-    result += "D3D11TextureKmt | ";
-  if (value & ExternalMemoryHandleTypeFlagBits::eD3D12Heap)
-    result += "D3D12Heap | ";
-  if (value & ExternalMemoryHandleTypeFlagBits::eD3D12Resource)
-    result += "D3D12Resource | ";
-  if (value & ExternalMemoryHandleTypeFlagBits::eDmaBufEXT)
-    result += "DmaBufEXT | ";
-#if defined(VK_USE_PLATFORM_ANDROID_KHR)
-  if (value & ExternalMemoryHandleTypeFlagBits::eAndroidHardwareBufferANDROID)
-    result += "AndroidHardwareBufferANDROID | ";
-#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
-  if (value & ExternalMemoryHandleTypeFlagBits::eHostAllocationEXT)
-    result += "HostAllocationEXT | ";
-  if (value & ExternalMemoryHandleTypeFlagBits::eHostMappedForeignMemoryEXT)
-    result += "HostMappedForeignMemoryEXT | ";
-#if defined(VK_USE_PLATFORM_FUCHSIA)
-  if (value & ExternalMemoryHandleTypeFlagBits::eZirconVmoFUCHSIA)
-    result += "ZirconVmoFUCHSIA | ";
-#endif /*VK_USE_PLATFORM_FUCHSIA*/
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-using ExternalMemoryHandleTypeFlagsNV =
-    Flags<ExternalMemoryHandleTypeFlagBitsNV>;
-
-template <> struct FlagTraits<ExternalMemoryHandleTypeFlagBitsNV> {
-  enum : VkFlags {
-    allFlags = VkFlags(ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32) |
-               VkFlags(ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32Kmt) |
-               VkFlags(ExternalMemoryHandleTypeFlagBitsNV::eD3D11Image) |
-               VkFlags(ExternalMemoryHandleTypeFlagBitsNV::eD3D11ImageKmt)
-  };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalMemoryHandleTypeFlagsNV
-operator|(ExternalMemoryHandleTypeFlagBitsNV bit0,
-          ExternalMemoryHandleTypeFlagBitsNV bit1) VULKAN_HPP_NOEXCEPT {
-  return ExternalMemoryHandleTypeFlagsNV(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalMemoryHandleTypeFlagsNV
-operator&(ExternalMemoryHandleTypeFlagBitsNV bit0,
-          ExternalMemoryHandleTypeFlagBitsNV bit1) VULKAN_HPP_NOEXCEPT {
-  return ExternalMemoryHandleTypeFlagsNV(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalMemoryHandleTypeFlagsNV
-operator^(ExternalMemoryHandleTypeFlagBitsNV bit0,
-          ExternalMemoryHandleTypeFlagBitsNV bit1) VULKAN_HPP_NOEXCEPT {
-  return ExternalMemoryHandleTypeFlagsNV(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalMemoryHandleTypeFlagsNV
-operator~(ExternalMemoryHandleTypeFlagBitsNV bits) VULKAN_HPP_NOEXCEPT {
-  return ~(ExternalMemoryHandleTypeFlagsNV(bits));
-}
-
-VULKAN_HPP_INLINE std::string to_string(ExternalMemoryHandleTypeFlagsNV value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32)
-    result += "OpaqueWin32 | ";
-  if (value & ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32Kmt)
-    result += "OpaqueWin32Kmt | ";
-  if (value & ExternalMemoryHandleTypeFlagBitsNV::eD3D11Image)
-    result += "D3D11Image | ";
-  if (value & ExternalMemoryHandleTypeFlagBitsNV::eD3D11ImageKmt)
-    result += "D3D11ImageKmt | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-using ExternalSemaphoreFeatureFlags = Flags<ExternalSemaphoreFeatureFlagBits>;
-
-template <> struct FlagTraits<ExternalSemaphoreFeatureFlagBits> {
-  enum : VkFlags {
-    allFlags = VkFlags(ExternalSemaphoreFeatureFlagBits::eExportable) |
-               VkFlags(ExternalSemaphoreFeatureFlagBits::eImportable)
-  };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalSemaphoreFeatureFlags
-operator|(ExternalSemaphoreFeatureFlagBits bit0,
-          ExternalSemaphoreFeatureFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return ExternalSemaphoreFeatureFlags(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalSemaphoreFeatureFlags
-operator&(ExternalSemaphoreFeatureFlagBits bit0,
-          ExternalSemaphoreFeatureFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return ExternalSemaphoreFeatureFlags(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalSemaphoreFeatureFlags
-operator^(ExternalSemaphoreFeatureFlagBits bit0,
-          ExternalSemaphoreFeatureFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return ExternalSemaphoreFeatureFlags(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalSemaphoreFeatureFlags
-operator~(ExternalSemaphoreFeatureFlagBits bits) VULKAN_HPP_NOEXCEPT {
-  return ~(ExternalSemaphoreFeatureFlags(bits));
-}
-
-using ExternalSemaphoreFeatureFlagsKHR = ExternalSemaphoreFeatureFlags;
-
-VULKAN_HPP_INLINE std::string to_string(ExternalSemaphoreFeatureFlags value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & ExternalSemaphoreFeatureFlagBits::eExportable)
-    result += "Exportable | ";
-  if (value & ExternalSemaphoreFeatureFlagBits::eImportable)
-    result += "Importable | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-using ExternalSemaphoreHandleTypeFlags =
-    Flags<ExternalSemaphoreHandleTypeFlagBits>;
-
-template <> struct FlagTraits<ExternalSemaphoreHandleTypeFlagBits> {
-  enum : VkFlags {
-    allFlags = VkFlags(ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd) |
-               VkFlags(ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32) |
-               VkFlags(ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32Kmt) |
-               VkFlags(ExternalSemaphoreHandleTypeFlagBits::eD3D12Fence) |
-               VkFlags(ExternalSemaphoreHandleTypeFlagBits::eSyncFd)
-#if defined(VK_USE_PLATFORM_FUCHSIA)
-               |
-               VkFlags(ExternalSemaphoreHandleTypeFlagBits::eZirconEventFUCHSIA)
-#endif /*VK_USE_PLATFORM_FUCHSIA*/
-  };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalSemaphoreHandleTypeFlags
-operator|(ExternalSemaphoreHandleTypeFlagBits bit0,
-          ExternalSemaphoreHandleTypeFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return ExternalSemaphoreHandleTypeFlags(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalSemaphoreHandleTypeFlags
-operator&(ExternalSemaphoreHandleTypeFlagBits bit0,
-          ExternalSemaphoreHandleTypeFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return ExternalSemaphoreHandleTypeFlags(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalSemaphoreHandleTypeFlags
-operator^(ExternalSemaphoreHandleTypeFlagBits bit0,
-          ExternalSemaphoreHandleTypeFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return ExternalSemaphoreHandleTypeFlags(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalSemaphoreHandleTypeFlags
-operator~(ExternalSemaphoreHandleTypeFlagBits bits) VULKAN_HPP_NOEXCEPT {
-  return ~(ExternalSemaphoreHandleTypeFlags(bits));
-}
-
-using ExternalSemaphoreHandleTypeFlagsKHR = ExternalSemaphoreHandleTypeFlags;
-
-VULKAN_HPP_INLINE std::string
-to_string(ExternalSemaphoreHandleTypeFlags value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd)
-    result += "OpaqueFd | ";
-  if (value & ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32)
-    result += "OpaqueWin32 | ";
-  if (value & ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32Kmt)
-    result += "OpaqueWin32Kmt | ";
-  if (value & ExternalSemaphoreHandleTypeFlagBits::eD3D12Fence)
-    result += "D3D12Fence | ";
-  if (value & ExternalSemaphoreHandleTypeFlagBits::eSyncFd)
-    result += "SyncFd | ";
-#if defined(VK_USE_PLATFORM_FUCHSIA)
-  if (value & ExternalSemaphoreHandleTypeFlagBits::eZirconEventFUCHSIA)
-    result += "ZirconEventFUCHSIA | ";
-#endif /*VK_USE_PLATFORM_FUCHSIA*/
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-using FenceCreateFlags = Flags<FenceCreateFlagBits>;
-
-template <> struct FlagTraits<FenceCreateFlagBits> {
-  enum : VkFlags { allFlags = VkFlags(FenceCreateFlagBits::eSignaled) };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR FenceCreateFlags operator|(
-    FenceCreateFlagBits bit0, FenceCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return FenceCreateFlags(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR FenceCreateFlags operator&(
-    FenceCreateFlagBits bit0, FenceCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return FenceCreateFlags(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR FenceCreateFlags operator^(
-    FenceCreateFlagBits bit0, FenceCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return FenceCreateFlags(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR FenceCreateFlags
-operator~(FenceCreateFlagBits bits) VULKAN_HPP_NOEXCEPT {
-  return ~(FenceCreateFlags(bits));
-}
-
-VULKAN_HPP_INLINE std::string to_string(FenceCreateFlags value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & FenceCreateFlagBits::eSignaled)
-    result += "Signaled | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-using FenceImportFlags = Flags<FenceImportFlagBits>;
-
-template <> struct FlagTraits<FenceImportFlagBits> {
-  enum : VkFlags { allFlags = VkFlags(FenceImportFlagBits::eTemporary) };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR FenceImportFlags operator|(
-    FenceImportFlagBits bit0, FenceImportFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return FenceImportFlags(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR FenceImportFlags operator&(
-    FenceImportFlagBits bit0, FenceImportFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return FenceImportFlags(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR FenceImportFlags operator^(
-    FenceImportFlagBits bit0, FenceImportFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return FenceImportFlags(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR FenceImportFlags
-operator~(FenceImportFlagBits bits) VULKAN_HPP_NOEXCEPT {
-  return ~(FenceImportFlags(bits));
-}
-
-using FenceImportFlagsKHR = FenceImportFlags;
-
-VULKAN_HPP_INLINE std::string to_string(FenceImportFlags value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & FenceImportFlagBits::eTemporary)
-    result += "Temporary | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
+//=== VK_VERSION_1_0 ===
 
 using FormatFeatureFlags = Flags<FormatFeatureFlagBits>;
 
@@ -15647,7 +14389,6 @@
 }
 
 VULKAN_HPP_INLINE std::string to_string(FormatFeatureFlags value) {
-
   if (!value)
     return "{}";
   std::string result;
@@ -15714,300 +14455,6 @@
   return "{ " + result.substr(0, result.size() - 3) + " }";
 }
 
-using FramebufferCreateFlags = Flags<FramebufferCreateFlagBits>;
-
-template <> struct FlagTraits<FramebufferCreateFlagBits> {
-  enum : VkFlags { allFlags = VkFlags(FramebufferCreateFlagBits::eImageless) };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR FramebufferCreateFlags
-operator|(FramebufferCreateFlagBits bit0,
-          FramebufferCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return FramebufferCreateFlags(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR FramebufferCreateFlags
-operator&(FramebufferCreateFlagBits bit0,
-          FramebufferCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return FramebufferCreateFlags(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR FramebufferCreateFlags
-operator^(FramebufferCreateFlagBits bit0,
-          FramebufferCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return FramebufferCreateFlags(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR FramebufferCreateFlags
-operator~(FramebufferCreateFlagBits bits) VULKAN_HPP_NOEXCEPT {
-  return ~(FramebufferCreateFlags(bits));
-}
-
-VULKAN_HPP_INLINE std::string to_string(FramebufferCreateFlags value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & FramebufferCreateFlagBits::eImageless)
-    result += "Imageless | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-using GeometryFlagsKHR = Flags<GeometryFlagBitsKHR>;
-
-template <> struct FlagTraits<GeometryFlagBitsKHR> {
-  enum : VkFlags {
-    allFlags = VkFlags(GeometryFlagBitsKHR::eOpaque) |
-               VkFlags(GeometryFlagBitsKHR::eNoDuplicateAnyHitInvocation)
-  };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR GeometryFlagsKHR operator|(
-    GeometryFlagBitsKHR bit0, GeometryFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
-  return GeometryFlagsKHR(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR GeometryFlagsKHR operator&(
-    GeometryFlagBitsKHR bit0, GeometryFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
-  return GeometryFlagsKHR(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR GeometryFlagsKHR operator^(
-    GeometryFlagBitsKHR bit0, GeometryFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
-  return GeometryFlagsKHR(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR GeometryFlagsKHR
-operator~(GeometryFlagBitsKHR bits) VULKAN_HPP_NOEXCEPT {
-  return ~(GeometryFlagsKHR(bits));
-}
-
-using GeometryFlagsNV = GeometryFlagsKHR;
-
-VULKAN_HPP_INLINE std::string to_string(GeometryFlagsKHR value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & GeometryFlagBitsKHR::eOpaque)
-    result += "Opaque | ";
-  if (value & GeometryFlagBitsKHR::eNoDuplicateAnyHitInvocation)
-    result += "NoDuplicateAnyHitInvocation | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-using GeometryInstanceFlagsKHR = Flags<GeometryInstanceFlagBitsKHR>;
-
-template <> struct FlagTraits<GeometryInstanceFlagBitsKHR> {
-  enum : VkFlags {
-    allFlags =
-        VkFlags(GeometryInstanceFlagBitsKHR::eTriangleFacingCullDisable) |
-        VkFlags(GeometryInstanceFlagBitsKHR::eTriangleFrontCounterclockwise) |
-        VkFlags(GeometryInstanceFlagBitsKHR::eForceOpaque) |
-        VkFlags(GeometryInstanceFlagBitsKHR::eForceNoOpaque)
-  };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR GeometryInstanceFlagsKHR
-operator|(GeometryInstanceFlagBitsKHR bit0,
-          GeometryInstanceFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
-  return GeometryInstanceFlagsKHR(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR GeometryInstanceFlagsKHR
-operator&(GeometryInstanceFlagBitsKHR bit0,
-          GeometryInstanceFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
-  return GeometryInstanceFlagsKHR(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR GeometryInstanceFlagsKHR
-operator^(GeometryInstanceFlagBitsKHR bit0,
-          GeometryInstanceFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
-  return GeometryInstanceFlagsKHR(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR GeometryInstanceFlagsKHR
-operator~(GeometryInstanceFlagBitsKHR bits) VULKAN_HPP_NOEXCEPT {
-  return ~(GeometryInstanceFlagsKHR(bits));
-}
-
-using GeometryInstanceFlagsNV = GeometryInstanceFlagsKHR;
-
-VULKAN_HPP_INLINE std::string to_string(GeometryInstanceFlagsKHR value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & GeometryInstanceFlagBitsKHR::eTriangleFacingCullDisable)
-    result += "TriangleFacingCullDisable | ";
-  if (value & GeometryInstanceFlagBitsKHR::eTriangleFrontCounterclockwise)
-    result += "TriangleFrontCounterclockwise | ";
-  if (value & GeometryInstanceFlagBitsKHR::eForceOpaque)
-    result += "ForceOpaque | ";
-  if (value & GeometryInstanceFlagBitsKHR::eForceNoOpaque)
-    result += "ForceNoOpaque | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-enum class HeadlessSurfaceCreateFlagBitsEXT : VkFlags {};
-
-VULKAN_HPP_INLINE std::string to_string(HeadlessSurfaceCreateFlagBitsEXT) {
-  return "(void)";
-}
-
-using HeadlessSurfaceCreateFlagsEXT = Flags<HeadlessSurfaceCreateFlagBitsEXT>;
-
-VULKAN_HPP_INLINE std::string to_string(HeadlessSurfaceCreateFlagsEXT) {
-
-  return "{}";
-}
-
-#if defined(VK_USE_PLATFORM_IOS_MVK)
-enum class IOSSurfaceCreateFlagBitsMVK : VkFlags {};
-
-VULKAN_HPP_INLINE std::string to_string(IOSSurfaceCreateFlagBitsMVK) {
-  return "(void)";
-}
-
-using IOSSurfaceCreateFlagsMVK = Flags<IOSSurfaceCreateFlagBitsMVK>;
-
-VULKAN_HPP_INLINE std::string to_string(IOSSurfaceCreateFlagsMVK) {
-
-  return "{}";
-}
-#endif /*VK_USE_PLATFORM_IOS_MVK*/
-
-using ImageAspectFlags = Flags<ImageAspectFlagBits>;
-
-template <> struct FlagTraits<ImageAspectFlagBits> {
-  enum : VkFlags {
-    allFlags = VkFlags(ImageAspectFlagBits::eColor) |
-               VkFlags(ImageAspectFlagBits::eDepth) |
-               VkFlags(ImageAspectFlagBits::eStencil) |
-               VkFlags(ImageAspectFlagBits::eMetadata) |
-               VkFlags(ImageAspectFlagBits::ePlane0) |
-               VkFlags(ImageAspectFlagBits::ePlane1) |
-               VkFlags(ImageAspectFlagBits::ePlane2) |
-               VkFlags(ImageAspectFlagBits::eMemoryPlane0EXT) |
-               VkFlags(ImageAspectFlagBits::eMemoryPlane1EXT) |
-               VkFlags(ImageAspectFlagBits::eMemoryPlane2EXT) |
-               VkFlags(ImageAspectFlagBits::eMemoryPlane3EXT)
-  };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ImageAspectFlags operator|(
-    ImageAspectFlagBits bit0, ImageAspectFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return ImageAspectFlags(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ImageAspectFlags operator&(
-    ImageAspectFlagBits bit0, ImageAspectFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return ImageAspectFlags(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ImageAspectFlags operator^(
-    ImageAspectFlagBits bit0, ImageAspectFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return ImageAspectFlags(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ImageAspectFlags
-operator~(ImageAspectFlagBits bits) VULKAN_HPP_NOEXCEPT {
-  return ~(ImageAspectFlags(bits));
-}
-
-VULKAN_HPP_INLINE std::string to_string(ImageAspectFlags value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & ImageAspectFlagBits::eColor)
-    result += "Color | ";
-  if (value & ImageAspectFlagBits::eDepth)
-    result += "Depth | ";
-  if (value & ImageAspectFlagBits::eStencil)
-    result += "Stencil | ";
-  if (value & ImageAspectFlagBits::eMetadata)
-    result += "Metadata | ";
-  if (value & ImageAspectFlagBits::ePlane0)
-    result += "Plane0 | ";
-  if (value & ImageAspectFlagBits::ePlane1)
-    result += "Plane1 | ";
-  if (value & ImageAspectFlagBits::ePlane2)
-    result += "Plane2 | ";
-  if (value & ImageAspectFlagBits::eMemoryPlane0EXT)
-    result += "MemoryPlane0EXT | ";
-  if (value & ImageAspectFlagBits::eMemoryPlane1EXT)
-    result += "MemoryPlane1EXT | ";
-  if (value & ImageAspectFlagBits::eMemoryPlane2EXT)
-    result += "MemoryPlane2EXT | ";
-  if (value & ImageAspectFlagBits::eMemoryPlane3EXT)
-    result += "MemoryPlane3EXT | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-#if defined(VK_USE_PLATFORM_FUCHSIA)
-
-using ImageConstraintsInfoFlagsFUCHSIA =
-    Flags<ImageConstraintsInfoFlagBitsFUCHSIA>;
-
-template <> struct FlagTraits<ImageConstraintsInfoFlagBitsFUCHSIA> {
-  enum : VkFlags {
-    allFlags = VkFlags(ImageConstraintsInfoFlagBitsFUCHSIA::eCpuReadRarely) |
-               VkFlags(ImageConstraintsInfoFlagBitsFUCHSIA::eCpuReadOften) |
-               VkFlags(ImageConstraintsInfoFlagBitsFUCHSIA::eCpuWriteRarely) |
-               VkFlags(ImageConstraintsInfoFlagBitsFUCHSIA::eCpuWriteOften) |
-               VkFlags(ImageConstraintsInfoFlagBitsFUCHSIA::eProtectedOptional)
-  };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ImageConstraintsInfoFlagsFUCHSIA
-operator|(ImageConstraintsInfoFlagBitsFUCHSIA bit0,
-          ImageConstraintsInfoFlagBitsFUCHSIA bit1) VULKAN_HPP_NOEXCEPT {
-  return ImageConstraintsInfoFlagsFUCHSIA(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ImageConstraintsInfoFlagsFUCHSIA
-operator&(ImageConstraintsInfoFlagBitsFUCHSIA bit0,
-          ImageConstraintsInfoFlagBitsFUCHSIA bit1) VULKAN_HPP_NOEXCEPT {
-  return ImageConstraintsInfoFlagsFUCHSIA(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ImageConstraintsInfoFlagsFUCHSIA
-operator^(ImageConstraintsInfoFlagBitsFUCHSIA bit0,
-          ImageConstraintsInfoFlagBitsFUCHSIA bit1) VULKAN_HPP_NOEXCEPT {
-  return ImageConstraintsInfoFlagsFUCHSIA(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ImageConstraintsInfoFlagsFUCHSIA
-operator~(ImageConstraintsInfoFlagBitsFUCHSIA bits) VULKAN_HPP_NOEXCEPT {
-  return ~(ImageConstraintsInfoFlagsFUCHSIA(bits));
-}
-
-VULKAN_HPP_INLINE std::string
-to_string(ImageConstraintsInfoFlagsFUCHSIA value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & ImageConstraintsInfoFlagBitsFUCHSIA::eCpuReadRarely)
-    result += "CpuReadRarely | ";
-  if (value & ImageConstraintsInfoFlagBitsFUCHSIA::eCpuReadOften)
-    result += "CpuReadOften | ";
-  if (value & ImageConstraintsInfoFlagBitsFUCHSIA::eCpuWriteRarely)
-    result += "CpuWriteRarely | ";
-  if (value & ImageConstraintsInfoFlagBitsFUCHSIA::eCpuWriteOften)
-    result += "CpuWriteOften | ";
-  if (value & ImageConstraintsInfoFlagBitsFUCHSIA::eProtectedOptional)
-    result += "ProtectedOptional | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-#endif /*VK_USE_PLATFORM_FUCHSIA*/
-
 using ImageCreateFlags = Flags<ImageCreateFlagBits>;
 
 template <> struct FlagTraits<ImageCreateFlagBits> {
@@ -16055,7 +14502,6 @@
 }
 
 VULKAN_HPP_INLINE std::string to_string(ImageCreateFlags value) {
-
   if (!value)
     return "{}";
   std::string result;
@@ -16097,33 +14543,6 @@
   return "{ " + result.substr(0, result.size() - 3) + " }";
 }
 
-#if defined(VK_USE_PLATFORM_FUCHSIA)
-
-using ImageFormatConstraintsFlagsFUCHSIA =
-    Flags<ImageFormatConstraintsFlagBitsFUCHSIA>;
-
-VULKAN_HPP_INLINE std::string to_string(ImageFormatConstraintsFlagsFUCHSIA) {
-
-  return "{}";
-}
-#endif /*VK_USE_PLATFORM_FUCHSIA*/
-
-#if defined(VK_USE_PLATFORM_FUCHSIA)
-enum class ImagePipeSurfaceCreateFlagBitsFUCHSIA : VkFlags {};
-
-VULKAN_HPP_INLINE std::string to_string(ImagePipeSurfaceCreateFlagBitsFUCHSIA) {
-  return "(void)";
-}
-
-using ImagePipeSurfaceCreateFlagsFUCHSIA =
-    Flags<ImagePipeSurfaceCreateFlagBitsFUCHSIA>;
-
-VULKAN_HPP_INLINE std::string to_string(ImagePipeSurfaceCreateFlagsFUCHSIA) {
-
-  return "{}";
-}
-#endif /*VK_USE_PLATFORM_FUCHSIA*/
-
 using ImageUsageFlags = Flags<ImageUsageFlagBits>;
 
 template <> struct FlagTraits<ImageUsageFlagBits> {
@@ -16162,7 +14581,6 @@
 }
 
 VULKAN_HPP_INLINE std::string to_string(ImageUsageFlags value) {
-
   if (!value)
     return "{}";
   std::string result;
@@ -16190,213 +14608,10 @@
   return "{ " + result.substr(0, result.size() - 3) + " }";
 }
 
-using ImageViewCreateFlags = Flags<ImageViewCreateFlagBits>;
-
-template <> struct FlagTraits<ImageViewCreateFlagBits> {
-  enum : VkFlags {
-    allFlags = VkFlags(ImageViewCreateFlagBits::eFragmentDensityMapDynamicEXT) |
-               VkFlags(ImageViewCreateFlagBits::eFragmentDensityMapDeferredEXT)
-  };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ImageViewCreateFlags
-operator|(ImageViewCreateFlagBits bit0,
-          ImageViewCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return ImageViewCreateFlags(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ImageViewCreateFlags
-operator&(ImageViewCreateFlagBits bit0,
-          ImageViewCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return ImageViewCreateFlags(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ImageViewCreateFlags
-operator^(ImageViewCreateFlagBits bit0,
-          ImageViewCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return ImageViewCreateFlags(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ImageViewCreateFlags
-operator~(ImageViewCreateFlagBits bits) VULKAN_HPP_NOEXCEPT {
-  return ~(ImageViewCreateFlags(bits));
-}
-
-VULKAN_HPP_INLINE std::string to_string(ImageViewCreateFlags value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & ImageViewCreateFlagBits::eFragmentDensityMapDynamicEXT)
-    result += "FragmentDensityMapDynamicEXT | ";
-  if (value & ImageViewCreateFlagBits::eFragmentDensityMapDeferredEXT)
-    result += "FragmentDensityMapDeferredEXT | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-using IndirectCommandsLayoutUsageFlagsNV =
-    Flags<IndirectCommandsLayoutUsageFlagBitsNV>;
-
-template <> struct FlagTraits<IndirectCommandsLayoutUsageFlagBitsNV> {
-  enum : VkFlags {
-    allFlags =
-        VkFlags(IndirectCommandsLayoutUsageFlagBitsNV::eExplicitPreprocess) |
-        VkFlags(IndirectCommandsLayoutUsageFlagBitsNV::eIndexedSequences) |
-        VkFlags(IndirectCommandsLayoutUsageFlagBitsNV::eUnorderedSequences)
-  };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutUsageFlagsNV
-operator|(IndirectCommandsLayoutUsageFlagBitsNV bit0,
-          IndirectCommandsLayoutUsageFlagBitsNV bit1) VULKAN_HPP_NOEXCEPT {
-  return IndirectCommandsLayoutUsageFlagsNV(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutUsageFlagsNV
-operator&(IndirectCommandsLayoutUsageFlagBitsNV bit0,
-          IndirectCommandsLayoutUsageFlagBitsNV bit1) VULKAN_HPP_NOEXCEPT {
-  return IndirectCommandsLayoutUsageFlagsNV(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutUsageFlagsNV
-operator^(IndirectCommandsLayoutUsageFlagBitsNV bit0,
-          IndirectCommandsLayoutUsageFlagBitsNV bit1) VULKAN_HPP_NOEXCEPT {
-  return IndirectCommandsLayoutUsageFlagsNV(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutUsageFlagsNV
-operator~(IndirectCommandsLayoutUsageFlagBitsNV bits) VULKAN_HPP_NOEXCEPT {
-  return ~(IndirectCommandsLayoutUsageFlagsNV(bits));
-}
-
-VULKAN_HPP_INLINE std::string
-to_string(IndirectCommandsLayoutUsageFlagsNV value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & IndirectCommandsLayoutUsageFlagBitsNV::eExplicitPreprocess)
-    result += "ExplicitPreprocess | ";
-  if (value & IndirectCommandsLayoutUsageFlagBitsNV::eIndexedSequences)
-    result += "IndexedSequences | ";
-  if (value & IndirectCommandsLayoutUsageFlagBitsNV::eUnorderedSequences)
-    result += "UnorderedSequences | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-using IndirectStateFlagsNV = Flags<IndirectStateFlagBitsNV>;
-
-template <> struct FlagTraits<IndirectStateFlagBitsNV> {
-  enum : VkFlags {
-    allFlags = VkFlags(IndirectStateFlagBitsNV::eFlagFrontface)
-  };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR IndirectStateFlagsNV
-operator|(IndirectStateFlagBitsNV bit0,
-          IndirectStateFlagBitsNV bit1) VULKAN_HPP_NOEXCEPT {
-  return IndirectStateFlagsNV(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR IndirectStateFlagsNV
-operator&(IndirectStateFlagBitsNV bit0,
-          IndirectStateFlagBitsNV bit1) VULKAN_HPP_NOEXCEPT {
-  return IndirectStateFlagsNV(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR IndirectStateFlagsNV
-operator^(IndirectStateFlagBitsNV bit0,
-          IndirectStateFlagBitsNV bit1) VULKAN_HPP_NOEXCEPT {
-  return IndirectStateFlagsNV(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR IndirectStateFlagsNV
-operator~(IndirectStateFlagBitsNV bits) VULKAN_HPP_NOEXCEPT {
-  return ~(IndirectStateFlagsNV(bits));
-}
-
-VULKAN_HPP_INLINE std::string to_string(IndirectStateFlagsNV value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & IndirectStateFlagBitsNV::eFlagFrontface)
-    result += "FlagFrontface | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
 using InstanceCreateFlags = Flags<InstanceCreateFlagBits>;
 
 VULKAN_HPP_INLINE std::string to_string(InstanceCreateFlags) { return "{}"; }
 
-#if defined(VK_USE_PLATFORM_MACOS_MVK)
-enum class MacOSSurfaceCreateFlagBitsMVK : VkFlags {};
-
-VULKAN_HPP_INLINE std::string to_string(MacOSSurfaceCreateFlagBitsMVK) {
-  return "(void)";
-}
-
-using MacOSSurfaceCreateFlagsMVK = Flags<MacOSSurfaceCreateFlagBitsMVK>;
-
-VULKAN_HPP_INLINE std::string to_string(MacOSSurfaceCreateFlagsMVK) {
-
-  return "{}";
-}
-#endif /*VK_USE_PLATFORM_MACOS_MVK*/
-
-using MemoryAllocateFlags = Flags<MemoryAllocateFlagBits>;
-
-template <> struct FlagTraits<MemoryAllocateFlagBits> {
-  enum : VkFlags {
-    allFlags = VkFlags(MemoryAllocateFlagBits::eDeviceMask) |
-               VkFlags(MemoryAllocateFlagBits::eDeviceAddress) |
-               VkFlags(MemoryAllocateFlagBits::eDeviceAddressCaptureReplay)
-  };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR MemoryAllocateFlags
-operator|(MemoryAllocateFlagBits bit0,
-          MemoryAllocateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return MemoryAllocateFlags(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR MemoryAllocateFlags
-operator&(MemoryAllocateFlagBits bit0,
-          MemoryAllocateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return MemoryAllocateFlags(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR MemoryAllocateFlags
-operator^(MemoryAllocateFlagBits bit0,
-          MemoryAllocateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return MemoryAllocateFlags(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR MemoryAllocateFlags
-operator~(MemoryAllocateFlagBits bits) VULKAN_HPP_NOEXCEPT {
-  return ~(MemoryAllocateFlags(bits));
-}
-
-using MemoryAllocateFlagsKHR = MemoryAllocateFlags;
-
-VULKAN_HPP_INLINE std::string to_string(MemoryAllocateFlags value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & MemoryAllocateFlagBits::eDeviceMask)
-    result += "DeviceMask | ";
-  if (value & MemoryAllocateFlagBits::eDeviceAddress)
-    result += "DeviceAddress | ";
-  if (value & MemoryAllocateFlagBits::eDeviceAddressCaptureReplay)
-    result += "DeviceAddressCaptureReplay | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
 using MemoryHeapFlags = Flags<MemoryHeapFlagBits>;
 
 template <> struct FlagTraits<MemoryHeapFlagBits> {
@@ -16427,7 +14642,6 @@
 }
 
 VULKAN_HPP_INLINE std::string to_string(MemoryHeapFlags value) {
-
   if (!value)
     return "{}";
   std::string result;
@@ -16439,74 +14653,6 @@
   return "{ " + result.substr(0, result.size() - 3) + " }";
 }
 
-enum class MemoryMapFlagBits : VkFlags {};
-
-VULKAN_HPP_INLINE std::string to_string(MemoryMapFlagBits) { return "(void)"; }
-
-using MemoryMapFlags = Flags<MemoryMapFlagBits>;
-
-VULKAN_HPP_INLINE std::string to_string(MemoryMapFlags) { return "{}"; }
-
-#if defined(VK_USE_PLATFORM_FUCHSIA)
-
-using MemoryOpFlagsFUCHSIA = Flags<MemoryOpFlagBitsFUCHSIA>;
-
-template <> struct FlagTraits<MemoryOpFlagBitsFUCHSIA> {
-  enum : VkFlags {
-    allFlags = VkFlags(MemoryOpFlagBitsFUCHSIA::eUnpin) |
-               VkFlags(MemoryOpFlagBitsFUCHSIA::eDecommit) |
-               VkFlags(MemoryOpFlagBitsFUCHSIA::ePin) |
-               VkFlags(MemoryOpFlagBitsFUCHSIA::eCommit) |
-               VkFlags(MemoryOpFlagBitsFUCHSIA::eLock) |
-               VkFlags(MemoryOpFlagBitsFUCHSIA::eUnlock)
-  };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR MemoryOpFlagsFUCHSIA
-operator|(MemoryOpFlagBitsFUCHSIA bit0,
-          MemoryOpFlagBitsFUCHSIA bit1) VULKAN_HPP_NOEXCEPT {
-  return MemoryOpFlagsFUCHSIA(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR MemoryOpFlagsFUCHSIA
-operator&(MemoryOpFlagBitsFUCHSIA bit0,
-          MemoryOpFlagBitsFUCHSIA bit1) VULKAN_HPP_NOEXCEPT {
-  return MemoryOpFlagsFUCHSIA(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR MemoryOpFlagsFUCHSIA
-operator^(MemoryOpFlagBitsFUCHSIA bit0,
-          MemoryOpFlagBitsFUCHSIA bit1) VULKAN_HPP_NOEXCEPT {
-  return MemoryOpFlagsFUCHSIA(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR MemoryOpFlagsFUCHSIA
-operator~(MemoryOpFlagBitsFUCHSIA bits) VULKAN_HPP_NOEXCEPT {
-  return ~(MemoryOpFlagsFUCHSIA(bits));
-}
-
-VULKAN_HPP_INLINE std::string to_string(MemoryOpFlagsFUCHSIA value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & MemoryOpFlagBitsFUCHSIA::eUnpin)
-    result += "Unpin | ";
-  if (value & MemoryOpFlagBitsFUCHSIA::eDecommit)
-    result += "Decommit | ";
-  if (value & MemoryOpFlagBitsFUCHSIA::ePin)
-    result += "Pin | ";
-  if (value & MemoryOpFlagBitsFUCHSIA::eCommit)
-    result += "Commit | ";
-  if (value & MemoryOpFlagBitsFUCHSIA::eLock)
-    result += "Lock | ";
-  if (value & MemoryOpFlagBitsFUCHSIA::eUnlock)
-    result += "Unlock | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-#endif /*VK_USE_PLATFORM_FUCHSIA*/
-
 using MemoryPropertyFlags = Flags<MemoryPropertyFlagBits>;
 
 template <> struct FlagTraits<MemoryPropertyFlagBits> {
@@ -16546,7 +14692,6 @@
 }
 
 VULKAN_HPP_INLINE std::string to_string(MemoryPropertyFlags value) {
-
   if (!value)
     return "{}";
   std::string result;
@@ -16570,582 +14715,150 @@
   return "{ " + result.substr(0, result.size() - 3) + " }";
 }
 
-#if defined(VK_USE_PLATFORM_METAL_EXT)
-enum class MetalSurfaceCreateFlagBitsEXT : VkFlags {};
+using QueueFlags = Flags<QueueFlagBits>;
 
-VULKAN_HPP_INLINE std::string to_string(MetalSurfaceCreateFlagBitsEXT) {
-  return "(void)";
-}
-
-using MetalSurfaceCreateFlagsEXT = Flags<MetalSurfaceCreateFlagBitsEXT>;
-
-VULKAN_HPP_INLINE std::string to_string(MetalSurfaceCreateFlagsEXT) {
-
-  return "{}";
-}
-#endif /*VK_USE_PLATFORM_METAL_EXT*/
-
-using PeerMemoryFeatureFlags = Flags<PeerMemoryFeatureFlagBits>;
-
-template <> struct FlagTraits<PeerMemoryFeatureFlagBits> {
+template <> struct FlagTraits<QueueFlagBits> {
   enum : VkFlags {
-    allFlags = VkFlags(PeerMemoryFeatureFlagBits::eCopySrc) |
-               VkFlags(PeerMemoryFeatureFlagBits::eCopyDst) |
-               VkFlags(PeerMemoryFeatureFlagBits::eGenericSrc) |
-               VkFlags(PeerMemoryFeatureFlagBits::eGenericDst)
+    allFlags = VkFlags(QueueFlagBits::eGraphics) |
+               VkFlags(QueueFlagBits::eCompute) |
+               VkFlags(QueueFlagBits::eTransfer) |
+               VkFlags(QueueFlagBits::eSparseBinding) |
+               VkFlags(QueueFlagBits::eProtected)
   };
 };
 
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PeerMemoryFeatureFlags
-operator|(PeerMemoryFeatureFlagBits bit0,
-          PeerMemoryFeatureFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return PeerMemoryFeatureFlags(bit0) | bit1;
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR QueueFlags
+operator|(QueueFlagBits bit0, QueueFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return QueueFlags(bit0) | bit1;
 }
 
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PeerMemoryFeatureFlags
-operator&(PeerMemoryFeatureFlagBits bit0,
-          PeerMemoryFeatureFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return PeerMemoryFeatureFlags(bit0) & bit1;
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR QueueFlags
+operator&(QueueFlagBits bit0, QueueFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return QueueFlags(bit0) & bit1;
 }
 
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PeerMemoryFeatureFlags
-operator^(PeerMemoryFeatureFlagBits bit0,
-          PeerMemoryFeatureFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return PeerMemoryFeatureFlags(bit0) ^ bit1;
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR QueueFlags
+operator^(QueueFlagBits bit0, QueueFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return QueueFlags(bit0) ^ bit1;
 }
 
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PeerMemoryFeatureFlags
-operator~(PeerMemoryFeatureFlagBits bits) VULKAN_HPP_NOEXCEPT {
-  return ~(PeerMemoryFeatureFlags(bits));
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR QueueFlags operator~(QueueFlagBits bits)
+    VULKAN_HPP_NOEXCEPT {
+  return ~(QueueFlags(bits));
 }
 
-using PeerMemoryFeatureFlagsKHR = PeerMemoryFeatureFlags;
-
-VULKAN_HPP_INLINE std::string to_string(PeerMemoryFeatureFlags value) {
-
+VULKAN_HPP_INLINE std::string to_string(QueueFlags value) {
   if (!value)
     return "{}";
   std::string result;
 
-  if (value & PeerMemoryFeatureFlagBits::eCopySrc)
-    result += "CopySrc | ";
-  if (value & PeerMemoryFeatureFlagBits::eCopyDst)
-    result += "CopyDst | ";
-  if (value & PeerMemoryFeatureFlagBits::eGenericSrc)
-    result += "GenericSrc | ";
-  if (value & PeerMemoryFeatureFlagBits::eGenericDst)
-    result += "GenericDst | ";
+  if (value & QueueFlagBits::eGraphics)
+    result += "Graphics | ";
+  if (value & QueueFlagBits::eCompute)
+    result += "Compute | ";
+  if (value & QueueFlagBits::eTransfer)
+    result += "Transfer | ";
+  if (value & QueueFlagBits::eSparseBinding)
+    result += "SparseBinding | ";
+  if (value & QueueFlagBits::eProtected)
+    result += "Protected | ";
   return "{ " + result.substr(0, result.size() - 3) + " }";
 }
 
-using PerformanceCounterDescriptionFlagsKHR =
-    Flags<PerformanceCounterDescriptionFlagBitsKHR>;
+using SampleCountFlags = Flags<SampleCountFlagBits>;
 
-template <> struct FlagTraits<PerformanceCounterDescriptionFlagBitsKHR> {
+template <> struct FlagTraits<SampleCountFlagBits> {
   enum : VkFlags {
     allFlags =
-        VkFlags(
-            PerformanceCounterDescriptionFlagBitsKHR::ePerformanceImpacting) |
-        VkFlags(PerformanceCounterDescriptionFlagBitsKHR::eConcurrentlyImpacted)
+        VkFlags(SampleCountFlagBits::e1) | VkFlags(SampleCountFlagBits::e2) |
+        VkFlags(SampleCountFlagBits::e4) | VkFlags(SampleCountFlagBits::e8) |
+        VkFlags(SampleCountFlagBits::e16) | VkFlags(SampleCountFlagBits::e32) |
+        VkFlags(SampleCountFlagBits::e64)
   };
 };
 
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PerformanceCounterDescriptionFlagsKHR
-operator|(PerformanceCounterDescriptionFlagBitsKHR bit0,
-          PerformanceCounterDescriptionFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
-  return PerformanceCounterDescriptionFlagsKHR(bit0) | bit1;
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SampleCountFlags operator|(
+    SampleCountFlagBits bit0, SampleCountFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return SampleCountFlags(bit0) | bit1;
 }
 
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PerformanceCounterDescriptionFlagsKHR
-operator&(PerformanceCounterDescriptionFlagBitsKHR bit0,
-          PerformanceCounterDescriptionFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
-  return PerformanceCounterDescriptionFlagsKHR(bit0) & bit1;
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SampleCountFlags operator&(
+    SampleCountFlagBits bit0, SampleCountFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return SampleCountFlags(bit0) & bit1;
 }
 
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PerformanceCounterDescriptionFlagsKHR
-operator^(PerformanceCounterDescriptionFlagBitsKHR bit0,
-          PerformanceCounterDescriptionFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
-  return PerformanceCounterDescriptionFlagsKHR(bit0) ^ bit1;
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SampleCountFlags operator^(
+    SampleCountFlagBits bit0, SampleCountFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return SampleCountFlags(bit0) ^ bit1;
 }
 
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PerformanceCounterDescriptionFlagsKHR
-operator~(PerformanceCounterDescriptionFlagBitsKHR bits) VULKAN_HPP_NOEXCEPT {
-  return ~(PerformanceCounterDescriptionFlagsKHR(bits));
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SampleCountFlags
+operator~(SampleCountFlagBits bits) VULKAN_HPP_NOEXCEPT {
+  return ~(SampleCountFlags(bits));
 }
 
-VULKAN_HPP_INLINE std::string
-to_string(PerformanceCounterDescriptionFlagsKHR value) {
-
+VULKAN_HPP_INLINE std::string to_string(SampleCountFlags value) {
   if (!value)
     return "{}";
   std::string result;
 
-  if (value & PerformanceCounterDescriptionFlagBitsKHR::ePerformanceImpacting)
-    result += "PerformanceImpacting | ";
-  if (value & PerformanceCounterDescriptionFlagBitsKHR::eConcurrentlyImpacted)
-    result += "ConcurrentlyImpacted | ";
+  if (value & SampleCountFlagBits::e1)
+    result += "1 | ";
+  if (value & SampleCountFlagBits::e2)
+    result += "2 | ";
+  if (value & SampleCountFlagBits::e4)
+    result += "4 | ";
+  if (value & SampleCountFlagBits::e8)
+    result += "8 | ";
+  if (value & SampleCountFlagBits::e16)
+    result += "16 | ";
+  if (value & SampleCountFlagBits::e32)
+    result += "32 | ";
+  if (value & SampleCountFlagBits::e64)
+    result += "64 | ";
   return "{ " + result.substr(0, result.size() - 3) + " }";
 }
 
-using PipelineCacheCreateFlags = Flags<PipelineCacheCreateFlagBits>;
+using DeviceCreateFlags = Flags<DeviceCreateFlagBits>;
 
-template <> struct FlagTraits<PipelineCacheCreateFlagBits> {
-  enum : VkFlags {
-    allFlags = VkFlags(PipelineCacheCreateFlagBits::eExternallySynchronizedEXT)
-  };
+VULKAN_HPP_INLINE std::string to_string(DeviceCreateFlags) { return "{}"; }
+
+using DeviceQueueCreateFlags = Flags<DeviceQueueCreateFlagBits>;
+
+template <> struct FlagTraits<DeviceQueueCreateFlagBits> {
+  enum : VkFlags { allFlags = VkFlags(DeviceQueueCreateFlagBits::eProtected) };
 };
 
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PipelineCacheCreateFlags
-operator|(PipelineCacheCreateFlagBits bit0,
-          PipelineCacheCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return PipelineCacheCreateFlags(bit0) | bit1;
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DeviceQueueCreateFlags
+operator|(DeviceQueueCreateFlagBits bit0,
+          DeviceQueueCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return DeviceQueueCreateFlags(bit0) | bit1;
 }
 
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PipelineCacheCreateFlags
-operator&(PipelineCacheCreateFlagBits bit0,
-          PipelineCacheCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return PipelineCacheCreateFlags(bit0) & bit1;
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DeviceQueueCreateFlags
+operator&(DeviceQueueCreateFlagBits bit0,
+          DeviceQueueCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return DeviceQueueCreateFlags(bit0) & bit1;
 }
 
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PipelineCacheCreateFlags
-operator^(PipelineCacheCreateFlagBits bit0,
-          PipelineCacheCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return PipelineCacheCreateFlags(bit0) ^ bit1;
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DeviceQueueCreateFlags
+operator^(DeviceQueueCreateFlagBits bit0,
+          DeviceQueueCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return DeviceQueueCreateFlags(bit0) ^ bit1;
 }
 
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PipelineCacheCreateFlags
-operator~(PipelineCacheCreateFlagBits bits) VULKAN_HPP_NOEXCEPT {
-  return ~(PipelineCacheCreateFlags(bits));
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DeviceQueueCreateFlags
+operator~(DeviceQueueCreateFlagBits bits) VULKAN_HPP_NOEXCEPT {
+  return ~(DeviceQueueCreateFlags(bits));
 }
 
-VULKAN_HPP_INLINE std::string to_string(PipelineCacheCreateFlags value) {
-
+VULKAN_HPP_INLINE std::string to_string(DeviceQueueCreateFlags value) {
   if (!value)
     return "{}";
   std::string result;
 
-  if (value & PipelineCacheCreateFlagBits::eExternallySynchronizedEXT)
-    result += "ExternallySynchronizedEXT | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-enum class PipelineColorBlendStateCreateFlagBits : VkFlags {};
-
-VULKAN_HPP_INLINE std::string to_string(PipelineColorBlendStateCreateFlagBits) {
-  return "(void)";
-}
-
-using PipelineColorBlendStateCreateFlags =
-    Flags<PipelineColorBlendStateCreateFlagBits>;
-
-VULKAN_HPP_INLINE std::string to_string(PipelineColorBlendStateCreateFlags) {
-
-  return "{}";
-}
-
-using PipelineCompilerControlFlagsAMD =
-    Flags<PipelineCompilerControlFlagBitsAMD>;
-
-VULKAN_HPP_INLINE std::string to_string(PipelineCompilerControlFlagsAMD) {
-
-  return "{}";
-}
-
-enum class PipelineCoverageModulationStateCreateFlagBitsNV : VkFlags {};
-
-VULKAN_HPP_INLINE std::string
-to_string(PipelineCoverageModulationStateCreateFlagBitsNV) {
-  return "(void)";
-}
-
-using PipelineCoverageModulationStateCreateFlagsNV =
-    Flags<PipelineCoverageModulationStateCreateFlagBitsNV>;
-
-VULKAN_HPP_INLINE std::string
-to_string(PipelineCoverageModulationStateCreateFlagsNV) {
-
-  return "{}";
-}
-
-enum class PipelineCoverageReductionStateCreateFlagBitsNV : VkFlags {};
-
-VULKAN_HPP_INLINE std::string
-to_string(PipelineCoverageReductionStateCreateFlagBitsNV) {
-  return "(void)";
-}
-
-using PipelineCoverageReductionStateCreateFlagsNV =
-    Flags<PipelineCoverageReductionStateCreateFlagBitsNV>;
-
-VULKAN_HPP_INLINE std::string
-to_string(PipelineCoverageReductionStateCreateFlagsNV) {
-
-  return "{}";
-}
-
-enum class PipelineCoverageToColorStateCreateFlagBitsNV : VkFlags {};
-
-VULKAN_HPP_INLINE std::string
-to_string(PipelineCoverageToColorStateCreateFlagBitsNV) {
-  return "(void)";
-}
-
-using PipelineCoverageToColorStateCreateFlagsNV =
-    Flags<PipelineCoverageToColorStateCreateFlagBitsNV>;
-
-VULKAN_HPP_INLINE std::string
-to_string(PipelineCoverageToColorStateCreateFlagsNV) {
-
-  return "{}";
-}
-
-using PipelineCreateFlags = Flags<PipelineCreateFlagBits>;
-
-template <> struct FlagTraits<PipelineCreateFlagBits> {
-  enum : VkFlags {
-    allFlags =
-        VkFlags(PipelineCreateFlagBits::eDisableOptimization) |
-        VkFlags(PipelineCreateFlagBits::eAllowDerivatives) |
-        VkFlags(PipelineCreateFlagBits::eDerivative) |
-        VkFlags(PipelineCreateFlagBits::eViewIndexFromDeviceIndex) |
-        VkFlags(PipelineCreateFlagBits::eDispatchBase) |
-        VkFlags(PipelineCreateFlagBits::eRayTracingNoNullAnyHitShadersKHR) |
-        VkFlags(PipelineCreateFlagBits::eRayTracingNoNullClosestHitShadersKHR) |
-        VkFlags(PipelineCreateFlagBits::eRayTracingNoNullMissShadersKHR) |
-        VkFlags(
-            PipelineCreateFlagBits::eRayTracingNoNullIntersectionShadersKHR) |
-        VkFlags(PipelineCreateFlagBits::eRayTracingSkipTrianglesKHR) |
-        VkFlags(PipelineCreateFlagBits::eRayTracingSkipAabbsKHR) |
-        VkFlags(PipelineCreateFlagBits::
-                    eRayTracingShaderGroupHandleCaptureReplayKHR) |
-        VkFlags(PipelineCreateFlagBits::eDeferCompileNV) |
-        VkFlags(PipelineCreateFlagBits::eCaptureStatisticsKHR) |
-        VkFlags(PipelineCreateFlagBits::eCaptureInternalRepresentationsKHR) |
-        VkFlags(PipelineCreateFlagBits::eIndirectBindableNV) |
-        VkFlags(PipelineCreateFlagBits::eLibraryKHR) |
-        VkFlags(PipelineCreateFlagBits::eFailOnPipelineCompileRequiredEXT) |
-        VkFlags(PipelineCreateFlagBits::eEarlyReturnOnFailureEXT)
-  };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PipelineCreateFlags
-operator|(PipelineCreateFlagBits bit0,
-          PipelineCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return PipelineCreateFlags(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PipelineCreateFlags
-operator&(PipelineCreateFlagBits bit0,
-          PipelineCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return PipelineCreateFlags(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PipelineCreateFlags
-operator^(PipelineCreateFlagBits bit0,
-          PipelineCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return PipelineCreateFlags(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PipelineCreateFlags
-operator~(PipelineCreateFlagBits bits) VULKAN_HPP_NOEXCEPT {
-  return ~(PipelineCreateFlags(bits));
-}
-
-VULKAN_HPP_INLINE std::string to_string(PipelineCreateFlags value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & PipelineCreateFlagBits::eDisableOptimization)
-    result += "DisableOptimization | ";
-  if (value & PipelineCreateFlagBits::eAllowDerivatives)
-    result += "AllowDerivatives | ";
-  if (value & PipelineCreateFlagBits::eDerivative)
-    result += "Derivative | ";
-  if (value & PipelineCreateFlagBits::eViewIndexFromDeviceIndex)
-    result += "ViewIndexFromDeviceIndex | ";
-  if (value & PipelineCreateFlagBits::eDispatchBase)
-    result += "DispatchBase | ";
-  if (value & PipelineCreateFlagBits::eRayTracingNoNullAnyHitShadersKHR)
-    result += "RayTracingNoNullAnyHitShadersKHR | ";
-  if (value & PipelineCreateFlagBits::eRayTracingNoNullClosestHitShadersKHR)
-    result += "RayTracingNoNullClosestHitShadersKHR | ";
-  if (value & PipelineCreateFlagBits::eRayTracingNoNullMissShadersKHR)
-    result += "RayTracingNoNullMissShadersKHR | ";
-  if (value & PipelineCreateFlagBits::eRayTracingNoNullIntersectionShadersKHR)
-    result += "RayTracingNoNullIntersectionShadersKHR | ";
-  if (value & PipelineCreateFlagBits::eRayTracingSkipTrianglesKHR)
-    result += "RayTracingSkipTrianglesKHR | ";
-  if (value & PipelineCreateFlagBits::eRayTracingSkipAabbsKHR)
-    result += "RayTracingSkipAabbsKHR | ";
-  if (value &
-      PipelineCreateFlagBits::eRayTracingShaderGroupHandleCaptureReplayKHR)
-    result += "RayTracingShaderGroupHandleCaptureReplayKHR | ";
-  if (value & PipelineCreateFlagBits::eDeferCompileNV)
-    result += "DeferCompileNV | ";
-  if (value & PipelineCreateFlagBits::eCaptureStatisticsKHR)
-    result += "CaptureStatisticsKHR | ";
-  if (value & PipelineCreateFlagBits::eCaptureInternalRepresentationsKHR)
-    result += "CaptureInternalRepresentationsKHR | ";
-  if (value & PipelineCreateFlagBits::eIndirectBindableNV)
-    result += "IndirectBindableNV | ";
-  if (value & PipelineCreateFlagBits::eLibraryKHR)
-    result += "LibraryKHR | ";
-  if (value & PipelineCreateFlagBits::eFailOnPipelineCompileRequiredEXT)
-    result += "FailOnPipelineCompileRequiredEXT | ";
-  if (value & PipelineCreateFlagBits::eEarlyReturnOnFailureEXT)
-    result += "EarlyReturnOnFailureEXT | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-using PipelineCreationFeedbackFlagsEXT =
-    Flags<PipelineCreationFeedbackFlagBitsEXT>;
-
-template <> struct FlagTraits<PipelineCreationFeedbackFlagBitsEXT> {
-  enum : VkFlags {
-    allFlags =
-        VkFlags(PipelineCreationFeedbackFlagBitsEXT::eValid) |
-        VkFlags(
-            PipelineCreationFeedbackFlagBitsEXT::eApplicationPipelineCacheHit) |
-        VkFlags(PipelineCreationFeedbackFlagBitsEXT::eBasePipelineAcceleration)
-  };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PipelineCreationFeedbackFlagsEXT
-operator|(PipelineCreationFeedbackFlagBitsEXT bit0,
-          PipelineCreationFeedbackFlagBitsEXT bit1) VULKAN_HPP_NOEXCEPT {
-  return PipelineCreationFeedbackFlagsEXT(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PipelineCreationFeedbackFlagsEXT
-operator&(PipelineCreationFeedbackFlagBitsEXT bit0,
-          PipelineCreationFeedbackFlagBitsEXT bit1) VULKAN_HPP_NOEXCEPT {
-  return PipelineCreationFeedbackFlagsEXT(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PipelineCreationFeedbackFlagsEXT
-operator^(PipelineCreationFeedbackFlagBitsEXT bit0,
-          PipelineCreationFeedbackFlagBitsEXT bit1) VULKAN_HPP_NOEXCEPT {
-  return PipelineCreationFeedbackFlagsEXT(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PipelineCreationFeedbackFlagsEXT
-operator~(PipelineCreationFeedbackFlagBitsEXT bits) VULKAN_HPP_NOEXCEPT {
-  return ~(PipelineCreationFeedbackFlagsEXT(bits));
-}
-
-VULKAN_HPP_INLINE std::string
-to_string(PipelineCreationFeedbackFlagsEXT value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & PipelineCreationFeedbackFlagBitsEXT::eValid)
-    result += "Valid | ";
-  if (value & PipelineCreationFeedbackFlagBitsEXT::eApplicationPipelineCacheHit)
-    result += "ApplicationPipelineCacheHit | ";
-  if (value & PipelineCreationFeedbackFlagBitsEXT::eBasePipelineAcceleration)
-    result += "BasePipelineAcceleration | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-enum class PipelineDepthStencilStateCreateFlagBits : VkFlags {};
-
-VULKAN_HPP_INLINE std::string
-to_string(PipelineDepthStencilStateCreateFlagBits) {
-  return "(void)";
-}
-
-using PipelineDepthStencilStateCreateFlags =
-    Flags<PipelineDepthStencilStateCreateFlagBits>;
-
-VULKAN_HPP_INLINE std::string to_string(PipelineDepthStencilStateCreateFlags) {
-
-  return "{}";
-}
-
-enum class PipelineDiscardRectangleStateCreateFlagBitsEXT : VkFlags {};
-
-VULKAN_HPP_INLINE std::string
-to_string(PipelineDiscardRectangleStateCreateFlagBitsEXT) {
-  return "(void)";
-}
-
-using PipelineDiscardRectangleStateCreateFlagsEXT =
-    Flags<PipelineDiscardRectangleStateCreateFlagBitsEXT>;
-
-VULKAN_HPP_INLINE std::string
-to_string(PipelineDiscardRectangleStateCreateFlagsEXT) {
-
-  return "{}";
-}
-
-enum class PipelineDynamicStateCreateFlagBits : VkFlags {};
-
-VULKAN_HPP_INLINE std::string to_string(PipelineDynamicStateCreateFlagBits) {
-  return "(void)";
-}
-
-using PipelineDynamicStateCreateFlags =
-    Flags<PipelineDynamicStateCreateFlagBits>;
-
-VULKAN_HPP_INLINE std::string to_string(PipelineDynamicStateCreateFlags) {
-
-  return "{}";
-}
-
-enum class PipelineInputAssemblyStateCreateFlagBits : VkFlags {};
-
-VULKAN_HPP_INLINE std::string
-to_string(PipelineInputAssemblyStateCreateFlagBits) {
-  return "(void)";
-}
-
-using PipelineInputAssemblyStateCreateFlags =
-    Flags<PipelineInputAssemblyStateCreateFlagBits>;
-
-VULKAN_HPP_INLINE std::string to_string(PipelineInputAssemblyStateCreateFlags) {
-
-  return "{}";
-}
-
-enum class PipelineLayoutCreateFlagBits : VkFlags {};
-
-VULKAN_HPP_INLINE std::string to_string(PipelineLayoutCreateFlagBits) {
-  return "(void)";
-}
-
-using PipelineLayoutCreateFlags = Flags<PipelineLayoutCreateFlagBits>;
-
-VULKAN_HPP_INLINE std::string to_string(PipelineLayoutCreateFlags) {
-
-  return "{}";
-}
-
-enum class PipelineMultisampleStateCreateFlagBits : VkFlags {};
-
-VULKAN_HPP_INLINE std::string
-to_string(PipelineMultisampleStateCreateFlagBits) {
-  return "(void)";
-}
-
-using PipelineMultisampleStateCreateFlags =
-    Flags<PipelineMultisampleStateCreateFlagBits>;
-
-VULKAN_HPP_INLINE std::string to_string(PipelineMultisampleStateCreateFlags) {
-
-  return "{}";
-}
-
-enum class PipelineRasterizationConservativeStateCreateFlagBitsEXT : VkFlags {};
-
-VULKAN_HPP_INLINE std::string
-to_string(PipelineRasterizationConservativeStateCreateFlagBitsEXT) {
-  return "(void)";
-}
-
-using PipelineRasterizationConservativeStateCreateFlagsEXT =
-    Flags<PipelineRasterizationConservativeStateCreateFlagBitsEXT>;
-
-VULKAN_HPP_INLINE std::string
-to_string(PipelineRasterizationConservativeStateCreateFlagsEXT) {
-
-  return "{}";
-}
-
-enum class PipelineRasterizationDepthClipStateCreateFlagBitsEXT : VkFlags {};
-
-VULKAN_HPP_INLINE std::string
-to_string(PipelineRasterizationDepthClipStateCreateFlagBitsEXT) {
-  return "(void)";
-}
-
-using PipelineRasterizationDepthClipStateCreateFlagsEXT =
-    Flags<PipelineRasterizationDepthClipStateCreateFlagBitsEXT>;
-
-VULKAN_HPP_INLINE std::string
-to_string(PipelineRasterizationDepthClipStateCreateFlagsEXT) {
-
-  return "{}";
-}
-
-enum class PipelineRasterizationStateCreateFlagBits : VkFlags {};
-
-VULKAN_HPP_INLINE std::string
-to_string(PipelineRasterizationStateCreateFlagBits) {
-  return "(void)";
-}
-
-using PipelineRasterizationStateCreateFlags =
-    Flags<PipelineRasterizationStateCreateFlagBits>;
-
-VULKAN_HPP_INLINE std::string to_string(PipelineRasterizationStateCreateFlags) {
-
-  return "{}";
-}
-
-enum class PipelineRasterizationStateStreamCreateFlagBitsEXT : VkFlags {};
-
-VULKAN_HPP_INLINE std::string
-to_string(PipelineRasterizationStateStreamCreateFlagBitsEXT) {
-  return "(void)";
-}
-
-using PipelineRasterizationStateStreamCreateFlagsEXT =
-    Flags<PipelineRasterizationStateStreamCreateFlagBitsEXT>;
-
-VULKAN_HPP_INLINE std::string
-to_string(PipelineRasterizationStateStreamCreateFlagsEXT) {
-
-  return "{}";
-}
-
-using PipelineShaderStageCreateFlags = Flags<PipelineShaderStageCreateFlagBits>;
-
-template <> struct FlagTraits<PipelineShaderStageCreateFlagBits> {
-  enum : VkFlags {
-    allFlags =
-        VkFlags(
-            PipelineShaderStageCreateFlagBits::eAllowVaryingSubgroupSizeEXT) |
-        VkFlags(PipelineShaderStageCreateFlagBits::eRequireFullSubgroupsEXT)
-  };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PipelineShaderStageCreateFlags
-operator|(PipelineShaderStageCreateFlagBits bit0,
-          PipelineShaderStageCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return PipelineShaderStageCreateFlags(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PipelineShaderStageCreateFlags
-operator&(PipelineShaderStageCreateFlagBits bit0,
-          PipelineShaderStageCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return PipelineShaderStageCreateFlags(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PipelineShaderStageCreateFlags
-operator^(PipelineShaderStageCreateFlagBits bit0,
-          PipelineShaderStageCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return PipelineShaderStageCreateFlags(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PipelineShaderStageCreateFlags
-operator~(PipelineShaderStageCreateFlagBits bits) VULKAN_HPP_NOEXCEPT {
-  return ~(PipelineShaderStageCreateFlags(bits));
-}
-
-VULKAN_HPP_INLINE std::string to_string(PipelineShaderStageCreateFlags value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & PipelineShaderStageCreateFlagBits::eAllowVaryingSubgroupSizeEXT)
-    result += "AllowVaryingSubgroupSizeEXT | ";
-  if (value & PipelineShaderStageCreateFlagBits::eRequireFullSubgroupsEXT)
-    result += "RequireFullSubgroupsEXT | ";
+  if (value & DeviceQueueCreateFlagBits::eProtected)
+    result += "Protected | ";
   return "{ " + result.substr(0, result.size() - 3) + " }";
 }
 
@@ -17207,7 +14920,6 @@
 }
 
 VULKAN_HPP_INLINE std::string to_string(PipelineStageFlags value) {
-
   if (!value)
     return "{}";
   std::string result;
@@ -17267,6 +14979,4138 @@
   return "{ " + result.substr(0, result.size() - 3) + " }";
 }
 
+enum class MemoryMapFlagBits : VkFlags {};
+
+VULKAN_HPP_INLINE std::string to_string(MemoryMapFlagBits) { return "(void)"; }
+
+using MemoryMapFlags = Flags<MemoryMapFlagBits>;
+
+VULKAN_HPP_INLINE std::string to_string(MemoryMapFlags) { return "{}"; }
+
+using ImageAspectFlags = Flags<ImageAspectFlagBits>;
+
+template <> struct FlagTraits<ImageAspectFlagBits> {
+  enum : VkFlags {
+    allFlags = VkFlags(ImageAspectFlagBits::eColor) |
+               VkFlags(ImageAspectFlagBits::eDepth) |
+               VkFlags(ImageAspectFlagBits::eStencil) |
+               VkFlags(ImageAspectFlagBits::eMetadata) |
+               VkFlags(ImageAspectFlagBits::ePlane0) |
+               VkFlags(ImageAspectFlagBits::ePlane1) |
+               VkFlags(ImageAspectFlagBits::ePlane2) |
+               VkFlags(ImageAspectFlagBits::eMemoryPlane0EXT) |
+               VkFlags(ImageAspectFlagBits::eMemoryPlane1EXT) |
+               VkFlags(ImageAspectFlagBits::eMemoryPlane2EXT) |
+               VkFlags(ImageAspectFlagBits::eMemoryPlane3EXT)
+  };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ImageAspectFlags operator|(
+    ImageAspectFlagBits bit0, ImageAspectFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return ImageAspectFlags(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ImageAspectFlags operator&(
+    ImageAspectFlagBits bit0, ImageAspectFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return ImageAspectFlags(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ImageAspectFlags operator^(
+    ImageAspectFlagBits bit0, ImageAspectFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return ImageAspectFlags(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ImageAspectFlags
+operator~(ImageAspectFlagBits bits) VULKAN_HPP_NOEXCEPT {
+  return ~(ImageAspectFlags(bits));
+}
+
+VULKAN_HPP_INLINE std::string to_string(ImageAspectFlags value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & ImageAspectFlagBits::eColor)
+    result += "Color | ";
+  if (value & ImageAspectFlagBits::eDepth)
+    result += "Depth | ";
+  if (value & ImageAspectFlagBits::eStencil)
+    result += "Stencil | ";
+  if (value & ImageAspectFlagBits::eMetadata)
+    result += "Metadata | ";
+  if (value & ImageAspectFlagBits::ePlane0)
+    result += "Plane0 | ";
+  if (value & ImageAspectFlagBits::ePlane1)
+    result += "Plane1 | ";
+  if (value & ImageAspectFlagBits::ePlane2)
+    result += "Plane2 | ";
+  if (value & ImageAspectFlagBits::eMemoryPlane0EXT)
+    result += "MemoryPlane0EXT | ";
+  if (value & ImageAspectFlagBits::eMemoryPlane1EXT)
+    result += "MemoryPlane1EXT | ";
+  if (value & ImageAspectFlagBits::eMemoryPlane2EXT)
+    result += "MemoryPlane2EXT | ";
+  if (value & ImageAspectFlagBits::eMemoryPlane3EXT)
+    result += "MemoryPlane3EXT | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+using SparseImageFormatFlags = Flags<SparseImageFormatFlagBits>;
+
+template <> struct FlagTraits<SparseImageFormatFlagBits> {
+  enum : VkFlags {
+    allFlags = VkFlags(SparseImageFormatFlagBits::eSingleMiptail) |
+               VkFlags(SparseImageFormatFlagBits::eAlignedMipSize) |
+               VkFlags(SparseImageFormatFlagBits::eNonstandardBlockSize)
+  };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SparseImageFormatFlags
+operator|(SparseImageFormatFlagBits bit0,
+          SparseImageFormatFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return SparseImageFormatFlags(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SparseImageFormatFlags
+operator&(SparseImageFormatFlagBits bit0,
+          SparseImageFormatFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return SparseImageFormatFlags(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SparseImageFormatFlags
+operator^(SparseImageFormatFlagBits bit0,
+          SparseImageFormatFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return SparseImageFormatFlags(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SparseImageFormatFlags
+operator~(SparseImageFormatFlagBits bits) VULKAN_HPP_NOEXCEPT {
+  return ~(SparseImageFormatFlags(bits));
+}
+
+VULKAN_HPP_INLINE std::string to_string(SparseImageFormatFlags value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & SparseImageFormatFlagBits::eSingleMiptail)
+    result += "SingleMiptail | ";
+  if (value & SparseImageFormatFlagBits::eAlignedMipSize)
+    result += "AlignedMipSize | ";
+  if (value & SparseImageFormatFlagBits::eNonstandardBlockSize)
+    result += "NonstandardBlockSize | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+using SparseMemoryBindFlags = Flags<SparseMemoryBindFlagBits>;
+
+template <> struct FlagTraits<SparseMemoryBindFlagBits> {
+  enum : VkFlags { allFlags = VkFlags(SparseMemoryBindFlagBits::eMetadata) };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SparseMemoryBindFlags
+operator|(SparseMemoryBindFlagBits bit0,
+          SparseMemoryBindFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return SparseMemoryBindFlags(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SparseMemoryBindFlags
+operator&(SparseMemoryBindFlagBits bit0,
+          SparseMemoryBindFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return SparseMemoryBindFlags(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SparseMemoryBindFlags
+operator^(SparseMemoryBindFlagBits bit0,
+          SparseMemoryBindFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return SparseMemoryBindFlags(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SparseMemoryBindFlags
+operator~(SparseMemoryBindFlagBits bits) VULKAN_HPP_NOEXCEPT {
+  return ~(SparseMemoryBindFlags(bits));
+}
+
+VULKAN_HPP_INLINE std::string to_string(SparseMemoryBindFlags value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & SparseMemoryBindFlagBits::eMetadata)
+    result += "Metadata | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+using FenceCreateFlags = Flags<FenceCreateFlagBits>;
+
+template <> struct FlagTraits<FenceCreateFlagBits> {
+  enum : VkFlags { allFlags = VkFlags(FenceCreateFlagBits::eSignaled) };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR FenceCreateFlags operator|(
+    FenceCreateFlagBits bit0, FenceCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return FenceCreateFlags(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR FenceCreateFlags operator&(
+    FenceCreateFlagBits bit0, FenceCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return FenceCreateFlags(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR FenceCreateFlags operator^(
+    FenceCreateFlagBits bit0, FenceCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return FenceCreateFlags(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR FenceCreateFlags
+operator~(FenceCreateFlagBits bits) VULKAN_HPP_NOEXCEPT {
+  return ~(FenceCreateFlags(bits));
+}
+
+VULKAN_HPP_INLINE std::string to_string(FenceCreateFlags value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & FenceCreateFlagBits::eSignaled)
+    result += "Signaled | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+enum class SemaphoreCreateFlagBits : VkFlags {};
+
+VULKAN_HPP_INLINE std::string to_string(SemaphoreCreateFlagBits) {
+  return "(void)";
+}
+
+using SemaphoreCreateFlags = Flags<SemaphoreCreateFlagBits>;
+
+VULKAN_HPP_INLINE std::string to_string(SemaphoreCreateFlags) { return "{}"; }
+
+using EventCreateFlags = Flags<EventCreateFlagBits>;
+
+template <> struct FlagTraits<EventCreateFlagBits> {
+  enum : VkFlags { allFlags = VkFlags(EventCreateFlagBits::eDeviceOnlyKHR) };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR EventCreateFlags operator|(
+    EventCreateFlagBits bit0, EventCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return EventCreateFlags(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR EventCreateFlags operator&(
+    EventCreateFlagBits bit0, EventCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return EventCreateFlags(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR EventCreateFlags operator^(
+    EventCreateFlagBits bit0, EventCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return EventCreateFlags(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR EventCreateFlags
+operator~(EventCreateFlagBits bits) VULKAN_HPP_NOEXCEPT {
+  return ~(EventCreateFlags(bits));
+}
+
+VULKAN_HPP_INLINE std::string to_string(EventCreateFlags value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & EventCreateFlagBits::eDeviceOnlyKHR)
+    result += "DeviceOnlyKHR | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+using QueryPipelineStatisticFlags = Flags<QueryPipelineStatisticFlagBits>;
+
+template <> struct FlagTraits<QueryPipelineStatisticFlagBits> {
+  enum : VkFlags {
+    allFlags =
+        VkFlags(QueryPipelineStatisticFlagBits::eInputAssemblyVertices) |
+        VkFlags(QueryPipelineStatisticFlagBits::eInputAssemblyPrimitives) |
+        VkFlags(QueryPipelineStatisticFlagBits::eVertexShaderInvocations) |
+        VkFlags(QueryPipelineStatisticFlagBits::eGeometryShaderInvocations) |
+        VkFlags(QueryPipelineStatisticFlagBits::eGeometryShaderPrimitives) |
+        VkFlags(QueryPipelineStatisticFlagBits::eClippingInvocations) |
+        VkFlags(QueryPipelineStatisticFlagBits::eClippingPrimitives) |
+        VkFlags(QueryPipelineStatisticFlagBits::eFragmentShaderInvocations) |
+        VkFlags(
+            QueryPipelineStatisticFlagBits::eTessellationControlShaderPatches) |
+        VkFlags(QueryPipelineStatisticFlagBits::
+                    eTessellationEvaluationShaderInvocations) |
+        VkFlags(QueryPipelineStatisticFlagBits::eComputeShaderInvocations)
+  };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR QueryPipelineStatisticFlags
+operator|(QueryPipelineStatisticFlagBits bit0,
+          QueryPipelineStatisticFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return QueryPipelineStatisticFlags(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR QueryPipelineStatisticFlags
+operator&(QueryPipelineStatisticFlagBits bit0,
+          QueryPipelineStatisticFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return QueryPipelineStatisticFlags(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR QueryPipelineStatisticFlags
+operator^(QueryPipelineStatisticFlagBits bit0,
+          QueryPipelineStatisticFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return QueryPipelineStatisticFlags(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR QueryPipelineStatisticFlags
+operator~(QueryPipelineStatisticFlagBits bits) VULKAN_HPP_NOEXCEPT {
+  return ~(QueryPipelineStatisticFlags(bits));
+}
+
+VULKAN_HPP_INLINE std::string to_string(QueryPipelineStatisticFlags value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & QueryPipelineStatisticFlagBits::eInputAssemblyVertices)
+    result += "InputAssemblyVertices | ";
+  if (value & QueryPipelineStatisticFlagBits::eInputAssemblyPrimitives)
+    result += "InputAssemblyPrimitives | ";
+  if (value & QueryPipelineStatisticFlagBits::eVertexShaderInvocations)
+    result += "VertexShaderInvocations | ";
+  if (value & QueryPipelineStatisticFlagBits::eGeometryShaderInvocations)
+    result += "GeometryShaderInvocations | ";
+  if (value & QueryPipelineStatisticFlagBits::eGeometryShaderPrimitives)
+    result += "GeometryShaderPrimitives | ";
+  if (value & QueryPipelineStatisticFlagBits::eClippingInvocations)
+    result += "ClippingInvocations | ";
+  if (value & QueryPipelineStatisticFlagBits::eClippingPrimitives)
+    result += "ClippingPrimitives | ";
+  if (value & QueryPipelineStatisticFlagBits::eFragmentShaderInvocations)
+    result += "FragmentShaderInvocations | ";
+  if (value & QueryPipelineStatisticFlagBits::eTessellationControlShaderPatches)
+    result += "TessellationControlShaderPatches | ";
+  if (value &
+      QueryPipelineStatisticFlagBits::eTessellationEvaluationShaderInvocations)
+    result += "TessellationEvaluationShaderInvocations | ";
+  if (value & QueryPipelineStatisticFlagBits::eComputeShaderInvocations)
+    result += "ComputeShaderInvocations | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+using QueryPoolCreateFlags = Flags<QueryPoolCreateFlagBits>;
+
+VULKAN_HPP_INLINE std::string to_string(QueryPoolCreateFlags) { return "{}"; }
+
+using QueryResultFlags = Flags<QueryResultFlagBits>;
+
+template <> struct FlagTraits<QueryResultFlagBits> {
+  enum : VkFlags {
+    allFlags = VkFlags(QueryResultFlagBits::e64) |
+               VkFlags(QueryResultFlagBits::eWait) |
+               VkFlags(QueryResultFlagBits::eWithAvailability) |
+               VkFlags(QueryResultFlagBits::ePartial)
+  };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR QueryResultFlags operator|(
+    QueryResultFlagBits bit0, QueryResultFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return QueryResultFlags(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR QueryResultFlags operator&(
+    QueryResultFlagBits bit0, QueryResultFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return QueryResultFlags(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR QueryResultFlags operator^(
+    QueryResultFlagBits bit0, QueryResultFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return QueryResultFlags(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR QueryResultFlags
+operator~(QueryResultFlagBits bits) VULKAN_HPP_NOEXCEPT {
+  return ~(QueryResultFlags(bits));
+}
+
+VULKAN_HPP_INLINE std::string to_string(QueryResultFlags value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & QueryResultFlagBits::e64)
+    result += "64 | ";
+  if (value & QueryResultFlagBits::eWait)
+    result += "Wait | ";
+  if (value & QueryResultFlagBits::eWithAvailability)
+    result += "WithAvailability | ";
+  if (value & QueryResultFlagBits::ePartial)
+    result += "Partial | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+using BufferCreateFlags = Flags<BufferCreateFlagBits>;
+
+template <> struct FlagTraits<BufferCreateFlagBits> {
+  enum : VkFlags {
+    allFlags = VkFlags(BufferCreateFlagBits::eSparseBinding) |
+               VkFlags(BufferCreateFlagBits::eSparseResidency) |
+               VkFlags(BufferCreateFlagBits::eSparseAliased) |
+               VkFlags(BufferCreateFlagBits::eProtected) |
+               VkFlags(BufferCreateFlagBits::eDeviceAddressCaptureReplay)
+  };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR BufferCreateFlags operator|(
+    BufferCreateFlagBits bit0, BufferCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return BufferCreateFlags(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR BufferCreateFlags operator&(
+    BufferCreateFlagBits bit0, BufferCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return BufferCreateFlags(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR BufferCreateFlags operator^(
+    BufferCreateFlagBits bit0, BufferCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return BufferCreateFlags(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR BufferCreateFlags
+operator~(BufferCreateFlagBits bits) VULKAN_HPP_NOEXCEPT {
+  return ~(BufferCreateFlags(bits));
+}
+
+VULKAN_HPP_INLINE std::string to_string(BufferCreateFlags value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & BufferCreateFlagBits::eSparseBinding)
+    result += "SparseBinding | ";
+  if (value & BufferCreateFlagBits::eSparseResidency)
+    result += "SparseResidency | ";
+  if (value & BufferCreateFlagBits::eSparseAliased)
+    result += "SparseAliased | ";
+  if (value & BufferCreateFlagBits::eProtected)
+    result += "Protected | ";
+  if (value & BufferCreateFlagBits::eDeviceAddressCaptureReplay)
+    result += "DeviceAddressCaptureReplay | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+using BufferUsageFlags = Flags<BufferUsageFlagBits>;
+
+template <> struct FlagTraits<BufferUsageFlagBits> {
+  enum : VkFlags {
+    allFlags =
+        VkFlags(BufferUsageFlagBits::eTransferSrc) |
+        VkFlags(BufferUsageFlagBits::eTransferDst) |
+        VkFlags(BufferUsageFlagBits::eUniformTexelBuffer) |
+        VkFlags(BufferUsageFlagBits::eStorageTexelBuffer) |
+        VkFlags(BufferUsageFlagBits::eUniformBuffer) |
+        VkFlags(BufferUsageFlagBits::eStorageBuffer) |
+        VkFlags(BufferUsageFlagBits::eIndexBuffer) |
+        VkFlags(BufferUsageFlagBits::eVertexBuffer) |
+        VkFlags(BufferUsageFlagBits::eIndirectBuffer) |
+        VkFlags(BufferUsageFlagBits::eShaderDeviceAddress) |
+        VkFlags(BufferUsageFlagBits::eTransformFeedbackBufferEXT) |
+        VkFlags(BufferUsageFlagBits::eTransformFeedbackCounterBufferEXT) |
+        VkFlags(BufferUsageFlagBits::eConditionalRenderingEXT) |
+        VkFlags(
+            BufferUsageFlagBits::eAccelerationStructureBuildInputReadOnlyKHR) |
+        VkFlags(BufferUsageFlagBits::eAccelerationStructureStorageKHR) |
+        VkFlags(BufferUsageFlagBits::eShaderBindingTableKHR)
+  };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR BufferUsageFlags operator|(
+    BufferUsageFlagBits bit0, BufferUsageFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return BufferUsageFlags(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR BufferUsageFlags operator&(
+    BufferUsageFlagBits bit0, BufferUsageFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return BufferUsageFlags(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR BufferUsageFlags operator^(
+    BufferUsageFlagBits bit0, BufferUsageFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return BufferUsageFlags(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR BufferUsageFlags
+operator~(BufferUsageFlagBits bits) VULKAN_HPP_NOEXCEPT {
+  return ~(BufferUsageFlags(bits));
+}
+
+VULKAN_HPP_INLINE std::string to_string(BufferUsageFlags value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & BufferUsageFlagBits::eTransferSrc)
+    result += "TransferSrc | ";
+  if (value & BufferUsageFlagBits::eTransferDst)
+    result += "TransferDst | ";
+  if (value & BufferUsageFlagBits::eUniformTexelBuffer)
+    result += "UniformTexelBuffer | ";
+  if (value & BufferUsageFlagBits::eStorageTexelBuffer)
+    result += "StorageTexelBuffer | ";
+  if (value & BufferUsageFlagBits::eUniformBuffer)
+    result += "UniformBuffer | ";
+  if (value & BufferUsageFlagBits::eStorageBuffer)
+    result += "StorageBuffer | ";
+  if (value & BufferUsageFlagBits::eIndexBuffer)
+    result += "IndexBuffer | ";
+  if (value & BufferUsageFlagBits::eVertexBuffer)
+    result += "VertexBuffer | ";
+  if (value & BufferUsageFlagBits::eIndirectBuffer)
+    result += "IndirectBuffer | ";
+  if (value & BufferUsageFlagBits::eShaderDeviceAddress)
+    result += "ShaderDeviceAddress | ";
+  if (value & BufferUsageFlagBits::eTransformFeedbackBufferEXT)
+    result += "TransformFeedbackBufferEXT | ";
+  if (value & BufferUsageFlagBits::eTransformFeedbackCounterBufferEXT)
+    result += "TransformFeedbackCounterBufferEXT | ";
+  if (value & BufferUsageFlagBits::eConditionalRenderingEXT)
+    result += "ConditionalRenderingEXT | ";
+  if (value & BufferUsageFlagBits::eAccelerationStructureBuildInputReadOnlyKHR)
+    result += "AccelerationStructureBuildInputReadOnlyKHR | ";
+  if (value & BufferUsageFlagBits::eAccelerationStructureStorageKHR)
+    result += "AccelerationStructureStorageKHR | ";
+  if (value & BufferUsageFlagBits::eShaderBindingTableKHR)
+    result += "ShaderBindingTableKHR | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+enum class BufferViewCreateFlagBits : VkFlags {};
+
+VULKAN_HPP_INLINE std::string to_string(BufferViewCreateFlagBits) {
+  return "(void)";
+}
+
+using BufferViewCreateFlags = Flags<BufferViewCreateFlagBits>;
+
+VULKAN_HPP_INLINE std::string to_string(BufferViewCreateFlags) { return "{}"; }
+
+using ImageViewCreateFlags = Flags<ImageViewCreateFlagBits>;
+
+template <> struct FlagTraits<ImageViewCreateFlagBits> {
+  enum : VkFlags {
+    allFlags = VkFlags(ImageViewCreateFlagBits::eFragmentDensityMapDynamicEXT) |
+               VkFlags(ImageViewCreateFlagBits::eFragmentDensityMapDeferredEXT)
+  };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ImageViewCreateFlags
+operator|(ImageViewCreateFlagBits bit0,
+          ImageViewCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return ImageViewCreateFlags(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ImageViewCreateFlags
+operator&(ImageViewCreateFlagBits bit0,
+          ImageViewCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return ImageViewCreateFlags(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ImageViewCreateFlags
+operator^(ImageViewCreateFlagBits bit0,
+          ImageViewCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return ImageViewCreateFlags(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ImageViewCreateFlags
+operator~(ImageViewCreateFlagBits bits) VULKAN_HPP_NOEXCEPT {
+  return ~(ImageViewCreateFlags(bits));
+}
+
+VULKAN_HPP_INLINE std::string to_string(ImageViewCreateFlags value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & ImageViewCreateFlagBits::eFragmentDensityMapDynamicEXT)
+    result += "FragmentDensityMapDynamicEXT | ";
+  if (value & ImageViewCreateFlagBits::eFragmentDensityMapDeferredEXT)
+    result += "FragmentDensityMapDeferredEXT | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+using ShaderModuleCreateFlags = Flags<ShaderModuleCreateFlagBits>;
+
+VULKAN_HPP_INLINE std::string to_string(ShaderModuleCreateFlags) {
+  return "{}";
+}
+
+using PipelineCacheCreateFlags = Flags<PipelineCacheCreateFlagBits>;
+
+template <> struct FlagTraits<PipelineCacheCreateFlagBits> {
+  enum : VkFlags {
+    allFlags = VkFlags(PipelineCacheCreateFlagBits::eExternallySynchronizedEXT)
+  };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PipelineCacheCreateFlags
+operator|(PipelineCacheCreateFlagBits bit0,
+          PipelineCacheCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return PipelineCacheCreateFlags(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PipelineCacheCreateFlags
+operator&(PipelineCacheCreateFlagBits bit0,
+          PipelineCacheCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return PipelineCacheCreateFlags(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PipelineCacheCreateFlags
+operator^(PipelineCacheCreateFlagBits bit0,
+          PipelineCacheCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return PipelineCacheCreateFlags(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PipelineCacheCreateFlags
+operator~(PipelineCacheCreateFlagBits bits) VULKAN_HPP_NOEXCEPT {
+  return ~(PipelineCacheCreateFlags(bits));
+}
+
+VULKAN_HPP_INLINE std::string to_string(PipelineCacheCreateFlags value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & PipelineCacheCreateFlagBits::eExternallySynchronizedEXT)
+    result += "ExternallySynchronizedEXT | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+using ColorComponentFlags = Flags<ColorComponentFlagBits>;
+
+template <> struct FlagTraits<ColorComponentFlagBits> {
+  enum : VkFlags {
+    allFlags = VkFlags(ColorComponentFlagBits::eR) |
+               VkFlags(ColorComponentFlagBits::eG) |
+               VkFlags(ColorComponentFlagBits::eB) |
+               VkFlags(ColorComponentFlagBits::eA)
+  };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ColorComponentFlags
+operator|(ColorComponentFlagBits bit0,
+          ColorComponentFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return ColorComponentFlags(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ColorComponentFlags
+operator&(ColorComponentFlagBits bit0,
+          ColorComponentFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return ColorComponentFlags(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ColorComponentFlags
+operator^(ColorComponentFlagBits bit0,
+          ColorComponentFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return ColorComponentFlags(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ColorComponentFlags
+operator~(ColorComponentFlagBits bits) VULKAN_HPP_NOEXCEPT {
+  return ~(ColorComponentFlags(bits));
+}
+
+VULKAN_HPP_INLINE std::string to_string(ColorComponentFlags value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & ColorComponentFlagBits::eR)
+    result += "R | ";
+  if (value & ColorComponentFlagBits::eG)
+    result += "G | ";
+  if (value & ColorComponentFlagBits::eB)
+    result += "B | ";
+  if (value & ColorComponentFlagBits::eA)
+    result += "A | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+using CullModeFlags = Flags<CullModeFlagBits>;
+
+template <> struct FlagTraits<CullModeFlagBits> {
+  enum : VkFlags {
+    allFlags = VkFlags(CullModeFlagBits::eNone) |
+               VkFlags(CullModeFlagBits::eFront) |
+               VkFlags(CullModeFlagBits::eBack) |
+               VkFlags(CullModeFlagBits::eFrontAndBack)
+  };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CullModeFlags
+operator|(CullModeFlagBits bit0, CullModeFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return CullModeFlags(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CullModeFlags
+operator&(CullModeFlagBits bit0, CullModeFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return CullModeFlags(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CullModeFlags
+operator^(CullModeFlagBits bit0, CullModeFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return CullModeFlags(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CullModeFlags
+operator~(CullModeFlagBits bits) VULKAN_HPP_NOEXCEPT {
+  return ~(CullModeFlags(bits));
+}
+
+VULKAN_HPP_INLINE std::string to_string(CullModeFlags value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & CullModeFlagBits::eFront)
+    result += "Front | ";
+  if (value & CullModeFlagBits::eBack)
+    result += "Back | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+enum class PipelineColorBlendStateCreateFlagBits : VkFlags {};
+
+VULKAN_HPP_INLINE std::string to_string(PipelineColorBlendStateCreateFlagBits) {
+  return "(void)";
+}
+
+using PipelineColorBlendStateCreateFlags =
+    Flags<PipelineColorBlendStateCreateFlagBits>;
+
+VULKAN_HPP_INLINE std::string to_string(PipelineColorBlendStateCreateFlags) {
+  return "{}";
+}
+
+using PipelineCreateFlags = Flags<PipelineCreateFlagBits>;
+
+template <> struct FlagTraits<PipelineCreateFlagBits> {
+  enum : VkFlags {
+    allFlags =
+        VkFlags(PipelineCreateFlagBits::eDisableOptimization) |
+        VkFlags(PipelineCreateFlagBits::eAllowDerivatives) |
+        VkFlags(PipelineCreateFlagBits::eDerivative) |
+        VkFlags(PipelineCreateFlagBits::eViewIndexFromDeviceIndex) |
+        VkFlags(PipelineCreateFlagBits::eDispatchBase) |
+        VkFlags(PipelineCreateFlagBits::eRayTracingNoNullAnyHitShadersKHR) |
+        VkFlags(PipelineCreateFlagBits::eRayTracingNoNullClosestHitShadersKHR) |
+        VkFlags(PipelineCreateFlagBits::eRayTracingNoNullMissShadersKHR) |
+        VkFlags(
+            PipelineCreateFlagBits::eRayTracingNoNullIntersectionShadersKHR) |
+        VkFlags(PipelineCreateFlagBits::eRayTracingSkipTrianglesKHR) |
+        VkFlags(PipelineCreateFlagBits::eRayTracingSkipAabbsKHR) |
+        VkFlags(PipelineCreateFlagBits::
+                    eRayTracingShaderGroupHandleCaptureReplayKHR) |
+        VkFlags(PipelineCreateFlagBits::eDeferCompileNV) |
+        VkFlags(PipelineCreateFlagBits::eCaptureStatisticsKHR) |
+        VkFlags(PipelineCreateFlagBits::eCaptureInternalRepresentationsKHR) |
+        VkFlags(PipelineCreateFlagBits::eIndirectBindableNV) |
+        VkFlags(PipelineCreateFlagBits::eLibraryKHR) |
+        VkFlags(PipelineCreateFlagBits::eFailOnPipelineCompileRequiredEXT) |
+        VkFlags(PipelineCreateFlagBits::eEarlyReturnOnFailureEXT)
+  };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PipelineCreateFlags
+operator|(PipelineCreateFlagBits bit0,
+          PipelineCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return PipelineCreateFlags(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PipelineCreateFlags
+operator&(PipelineCreateFlagBits bit0,
+          PipelineCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return PipelineCreateFlags(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PipelineCreateFlags
+operator^(PipelineCreateFlagBits bit0,
+          PipelineCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return PipelineCreateFlags(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PipelineCreateFlags
+operator~(PipelineCreateFlagBits bits) VULKAN_HPP_NOEXCEPT {
+  return ~(PipelineCreateFlags(bits));
+}
+
+VULKAN_HPP_INLINE std::string to_string(PipelineCreateFlags value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & PipelineCreateFlagBits::eDisableOptimization)
+    result += "DisableOptimization | ";
+  if (value & PipelineCreateFlagBits::eAllowDerivatives)
+    result += "AllowDerivatives | ";
+  if (value & PipelineCreateFlagBits::eDerivative)
+    result += "Derivative | ";
+  if (value & PipelineCreateFlagBits::eViewIndexFromDeviceIndex)
+    result += "ViewIndexFromDeviceIndex | ";
+  if (value & PipelineCreateFlagBits::eDispatchBase)
+    result += "DispatchBase | ";
+  if (value & PipelineCreateFlagBits::eRayTracingNoNullAnyHitShadersKHR)
+    result += "RayTracingNoNullAnyHitShadersKHR | ";
+  if (value & PipelineCreateFlagBits::eRayTracingNoNullClosestHitShadersKHR)
+    result += "RayTracingNoNullClosestHitShadersKHR | ";
+  if (value & PipelineCreateFlagBits::eRayTracingNoNullMissShadersKHR)
+    result += "RayTracingNoNullMissShadersKHR | ";
+  if (value & PipelineCreateFlagBits::eRayTracingNoNullIntersectionShadersKHR)
+    result += "RayTracingNoNullIntersectionShadersKHR | ";
+  if (value & PipelineCreateFlagBits::eRayTracingSkipTrianglesKHR)
+    result += "RayTracingSkipTrianglesKHR | ";
+  if (value & PipelineCreateFlagBits::eRayTracingSkipAabbsKHR)
+    result += "RayTracingSkipAabbsKHR | ";
+  if (value &
+      PipelineCreateFlagBits::eRayTracingShaderGroupHandleCaptureReplayKHR)
+    result += "RayTracingShaderGroupHandleCaptureReplayKHR | ";
+  if (value & PipelineCreateFlagBits::eDeferCompileNV)
+    result += "DeferCompileNV | ";
+  if (value & PipelineCreateFlagBits::eCaptureStatisticsKHR)
+    result += "CaptureStatisticsKHR | ";
+  if (value & PipelineCreateFlagBits::eCaptureInternalRepresentationsKHR)
+    result += "CaptureInternalRepresentationsKHR | ";
+  if (value & PipelineCreateFlagBits::eIndirectBindableNV)
+    result += "IndirectBindableNV | ";
+  if (value & PipelineCreateFlagBits::eLibraryKHR)
+    result += "LibraryKHR | ";
+  if (value & PipelineCreateFlagBits::eFailOnPipelineCompileRequiredEXT)
+    result += "FailOnPipelineCompileRequiredEXT | ";
+  if (value & PipelineCreateFlagBits::eEarlyReturnOnFailureEXT)
+    result += "EarlyReturnOnFailureEXT | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+enum class PipelineDepthStencilStateCreateFlagBits : VkFlags {};
+
+VULKAN_HPP_INLINE std::string
+to_string(PipelineDepthStencilStateCreateFlagBits) {
+  return "(void)";
+}
+
+using PipelineDepthStencilStateCreateFlags =
+    Flags<PipelineDepthStencilStateCreateFlagBits>;
+
+VULKAN_HPP_INLINE std::string to_string(PipelineDepthStencilStateCreateFlags) {
+  return "{}";
+}
+
+enum class PipelineDynamicStateCreateFlagBits : VkFlags {};
+
+VULKAN_HPP_INLINE std::string to_string(PipelineDynamicStateCreateFlagBits) {
+  return "(void)";
+}
+
+using PipelineDynamicStateCreateFlags =
+    Flags<PipelineDynamicStateCreateFlagBits>;
+
+VULKAN_HPP_INLINE std::string to_string(PipelineDynamicStateCreateFlags) {
+  return "{}";
+}
+
+enum class PipelineInputAssemblyStateCreateFlagBits : VkFlags {};
+
+VULKAN_HPP_INLINE std::string
+to_string(PipelineInputAssemblyStateCreateFlagBits) {
+  return "(void)";
+}
+
+using PipelineInputAssemblyStateCreateFlags =
+    Flags<PipelineInputAssemblyStateCreateFlagBits>;
+
+VULKAN_HPP_INLINE std::string to_string(PipelineInputAssemblyStateCreateFlags) {
+  return "{}";
+}
+
+enum class PipelineLayoutCreateFlagBits : VkFlags {};
+
+VULKAN_HPP_INLINE std::string to_string(PipelineLayoutCreateFlagBits) {
+  return "(void)";
+}
+
+using PipelineLayoutCreateFlags = Flags<PipelineLayoutCreateFlagBits>;
+
+VULKAN_HPP_INLINE std::string to_string(PipelineLayoutCreateFlags) {
+  return "{}";
+}
+
+enum class PipelineMultisampleStateCreateFlagBits : VkFlags {};
+
+VULKAN_HPP_INLINE std::string
+to_string(PipelineMultisampleStateCreateFlagBits) {
+  return "(void)";
+}
+
+using PipelineMultisampleStateCreateFlags =
+    Flags<PipelineMultisampleStateCreateFlagBits>;
+
+VULKAN_HPP_INLINE std::string to_string(PipelineMultisampleStateCreateFlags) {
+  return "{}";
+}
+
+enum class PipelineRasterizationStateCreateFlagBits : VkFlags {};
+
+VULKAN_HPP_INLINE std::string
+to_string(PipelineRasterizationStateCreateFlagBits) {
+  return "(void)";
+}
+
+using PipelineRasterizationStateCreateFlags =
+    Flags<PipelineRasterizationStateCreateFlagBits>;
+
+VULKAN_HPP_INLINE std::string to_string(PipelineRasterizationStateCreateFlags) {
+  return "{}";
+}
+
+using PipelineShaderStageCreateFlags = Flags<PipelineShaderStageCreateFlagBits>;
+
+template <> struct FlagTraits<PipelineShaderStageCreateFlagBits> {
+  enum : VkFlags {
+    allFlags =
+        VkFlags(
+            PipelineShaderStageCreateFlagBits::eAllowVaryingSubgroupSizeEXT) |
+        VkFlags(PipelineShaderStageCreateFlagBits::eRequireFullSubgroupsEXT)
+  };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PipelineShaderStageCreateFlags
+operator|(PipelineShaderStageCreateFlagBits bit0,
+          PipelineShaderStageCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return PipelineShaderStageCreateFlags(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PipelineShaderStageCreateFlags
+operator&(PipelineShaderStageCreateFlagBits bit0,
+          PipelineShaderStageCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return PipelineShaderStageCreateFlags(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PipelineShaderStageCreateFlags
+operator^(PipelineShaderStageCreateFlagBits bit0,
+          PipelineShaderStageCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return PipelineShaderStageCreateFlags(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PipelineShaderStageCreateFlags
+operator~(PipelineShaderStageCreateFlagBits bits) VULKAN_HPP_NOEXCEPT {
+  return ~(PipelineShaderStageCreateFlags(bits));
+}
+
+VULKAN_HPP_INLINE std::string to_string(PipelineShaderStageCreateFlags value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & PipelineShaderStageCreateFlagBits::eAllowVaryingSubgroupSizeEXT)
+    result += "AllowVaryingSubgroupSizeEXT | ";
+  if (value & PipelineShaderStageCreateFlagBits::eRequireFullSubgroupsEXT)
+    result += "RequireFullSubgroupsEXT | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+enum class PipelineTessellationStateCreateFlagBits : VkFlags {};
+
+VULKAN_HPP_INLINE std::string
+to_string(PipelineTessellationStateCreateFlagBits) {
+  return "(void)";
+}
+
+using PipelineTessellationStateCreateFlags =
+    Flags<PipelineTessellationStateCreateFlagBits>;
+
+VULKAN_HPP_INLINE std::string to_string(PipelineTessellationStateCreateFlags) {
+  return "{}";
+}
+
+enum class PipelineVertexInputStateCreateFlagBits : VkFlags {};
+
+VULKAN_HPP_INLINE std::string
+to_string(PipelineVertexInputStateCreateFlagBits) {
+  return "(void)";
+}
+
+using PipelineVertexInputStateCreateFlags =
+    Flags<PipelineVertexInputStateCreateFlagBits>;
+
+VULKAN_HPP_INLINE std::string to_string(PipelineVertexInputStateCreateFlags) {
+  return "{}";
+}
+
+enum class PipelineViewportStateCreateFlagBits : VkFlags {};
+
+VULKAN_HPP_INLINE std::string to_string(PipelineViewportStateCreateFlagBits) {
+  return "(void)";
+}
+
+using PipelineViewportStateCreateFlags =
+    Flags<PipelineViewportStateCreateFlagBits>;
+
+VULKAN_HPP_INLINE std::string to_string(PipelineViewportStateCreateFlags) {
+  return "{}";
+}
+
+using ShaderStageFlags = Flags<ShaderStageFlagBits>;
+
+template <> struct FlagTraits<ShaderStageFlagBits> {
+  enum : VkFlags {
+    allFlags = VkFlags(ShaderStageFlagBits::eVertex) |
+               VkFlags(ShaderStageFlagBits::eTessellationControl) |
+               VkFlags(ShaderStageFlagBits::eTessellationEvaluation) |
+               VkFlags(ShaderStageFlagBits::eGeometry) |
+               VkFlags(ShaderStageFlagBits::eFragment) |
+               VkFlags(ShaderStageFlagBits::eCompute) |
+               VkFlags(ShaderStageFlagBits::eAllGraphics) |
+               VkFlags(ShaderStageFlagBits::eAll) |
+               VkFlags(ShaderStageFlagBits::eRaygenKHR) |
+               VkFlags(ShaderStageFlagBits::eAnyHitKHR) |
+               VkFlags(ShaderStageFlagBits::eClosestHitKHR) |
+               VkFlags(ShaderStageFlagBits::eMissKHR) |
+               VkFlags(ShaderStageFlagBits::eIntersectionKHR) |
+               VkFlags(ShaderStageFlagBits::eCallableKHR) |
+               VkFlags(ShaderStageFlagBits::eTaskNV) |
+               VkFlags(ShaderStageFlagBits::eMeshNV)
+  };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ShaderStageFlags operator|(
+    ShaderStageFlagBits bit0, ShaderStageFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return ShaderStageFlags(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ShaderStageFlags operator&(
+    ShaderStageFlagBits bit0, ShaderStageFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return ShaderStageFlags(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ShaderStageFlags operator^(
+    ShaderStageFlagBits bit0, ShaderStageFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return ShaderStageFlags(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ShaderStageFlags
+operator~(ShaderStageFlagBits bits) VULKAN_HPP_NOEXCEPT {
+  return ~(ShaderStageFlags(bits));
+}
+
+VULKAN_HPP_INLINE std::string to_string(ShaderStageFlags value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & ShaderStageFlagBits::eVertex)
+    result += "Vertex | ";
+  if (value & ShaderStageFlagBits::eTessellationControl)
+    result += "TessellationControl | ";
+  if (value & ShaderStageFlagBits::eTessellationEvaluation)
+    result += "TessellationEvaluation | ";
+  if (value & ShaderStageFlagBits::eGeometry)
+    result += "Geometry | ";
+  if (value & ShaderStageFlagBits::eFragment)
+    result += "Fragment | ";
+  if (value & ShaderStageFlagBits::eCompute)
+    result += "Compute | ";
+  if (value & ShaderStageFlagBits::eRaygenKHR)
+    result += "RaygenKHR | ";
+  if (value & ShaderStageFlagBits::eAnyHitKHR)
+    result += "AnyHitKHR | ";
+  if (value & ShaderStageFlagBits::eClosestHitKHR)
+    result += "ClosestHitKHR | ";
+  if (value & ShaderStageFlagBits::eMissKHR)
+    result += "MissKHR | ";
+  if (value & ShaderStageFlagBits::eIntersectionKHR)
+    result += "IntersectionKHR | ";
+  if (value & ShaderStageFlagBits::eCallableKHR)
+    result += "CallableKHR | ";
+  if (value & ShaderStageFlagBits::eTaskNV)
+    result += "TaskNV | ";
+  if (value & ShaderStageFlagBits::eMeshNV)
+    result += "MeshNV | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+using SamplerCreateFlags = Flags<SamplerCreateFlagBits>;
+
+template <> struct FlagTraits<SamplerCreateFlagBits> {
+  enum : VkFlags {
+    allFlags =
+        VkFlags(SamplerCreateFlagBits::eSubsampledEXT) |
+        VkFlags(SamplerCreateFlagBits::eSubsampledCoarseReconstructionEXT)
+  };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SamplerCreateFlags
+operator|(SamplerCreateFlagBits bit0,
+          SamplerCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return SamplerCreateFlags(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SamplerCreateFlags
+operator&(SamplerCreateFlagBits bit0,
+          SamplerCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return SamplerCreateFlags(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SamplerCreateFlags
+operator^(SamplerCreateFlagBits bit0,
+          SamplerCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return SamplerCreateFlags(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SamplerCreateFlags
+operator~(SamplerCreateFlagBits bits) VULKAN_HPP_NOEXCEPT {
+  return ~(SamplerCreateFlags(bits));
+}
+
+VULKAN_HPP_INLINE std::string to_string(SamplerCreateFlags value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & SamplerCreateFlagBits::eSubsampledEXT)
+    result += "SubsampledEXT | ";
+  if (value & SamplerCreateFlagBits::eSubsampledCoarseReconstructionEXT)
+    result += "SubsampledCoarseReconstructionEXT | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+using DescriptorPoolCreateFlags = Flags<DescriptorPoolCreateFlagBits>;
+
+template <> struct FlagTraits<DescriptorPoolCreateFlagBits> {
+  enum : VkFlags {
+    allFlags = VkFlags(DescriptorPoolCreateFlagBits::eFreeDescriptorSet) |
+               VkFlags(DescriptorPoolCreateFlagBits::eUpdateAfterBind) |
+               VkFlags(DescriptorPoolCreateFlagBits::eHostOnlyVALVE)
+  };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DescriptorPoolCreateFlags
+operator|(DescriptorPoolCreateFlagBits bit0,
+          DescriptorPoolCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return DescriptorPoolCreateFlags(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DescriptorPoolCreateFlags
+operator&(DescriptorPoolCreateFlagBits bit0,
+          DescriptorPoolCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return DescriptorPoolCreateFlags(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DescriptorPoolCreateFlags
+operator^(DescriptorPoolCreateFlagBits bit0,
+          DescriptorPoolCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return DescriptorPoolCreateFlags(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DescriptorPoolCreateFlags
+operator~(DescriptorPoolCreateFlagBits bits) VULKAN_HPP_NOEXCEPT {
+  return ~(DescriptorPoolCreateFlags(bits));
+}
+
+VULKAN_HPP_INLINE std::string to_string(DescriptorPoolCreateFlags value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & DescriptorPoolCreateFlagBits::eFreeDescriptorSet)
+    result += "FreeDescriptorSet | ";
+  if (value & DescriptorPoolCreateFlagBits::eUpdateAfterBind)
+    result += "UpdateAfterBind | ";
+  if (value & DescriptorPoolCreateFlagBits::eHostOnlyVALVE)
+    result += "HostOnlyVALVE | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+enum class DescriptorPoolResetFlagBits : VkFlags {};
+
+VULKAN_HPP_INLINE std::string to_string(DescriptorPoolResetFlagBits) {
+  return "(void)";
+}
+
+using DescriptorPoolResetFlags = Flags<DescriptorPoolResetFlagBits>;
+
+VULKAN_HPP_INLINE std::string to_string(DescriptorPoolResetFlags) {
+  return "{}";
+}
+
+using DescriptorSetLayoutCreateFlags = Flags<DescriptorSetLayoutCreateFlagBits>;
+
+template <> struct FlagTraits<DescriptorSetLayoutCreateFlagBits> {
+  enum : VkFlags {
+    allFlags =
+        VkFlags(DescriptorSetLayoutCreateFlagBits::eUpdateAfterBindPool) |
+        VkFlags(DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR) |
+        VkFlags(DescriptorSetLayoutCreateFlagBits::eHostOnlyPoolVALVE)
+  };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DescriptorSetLayoutCreateFlags
+operator|(DescriptorSetLayoutCreateFlagBits bit0,
+          DescriptorSetLayoutCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return DescriptorSetLayoutCreateFlags(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DescriptorSetLayoutCreateFlags
+operator&(DescriptorSetLayoutCreateFlagBits bit0,
+          DescriptorSetLayoutCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return DescriptorSetLayoutCreateFlags(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DescriptorSetLayoutCreateFlags
+operator^(DescriptorSetLayoutCreateFlagBits bit0,
+          DescriptorSetLayoutCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return DescriptorSetLayoutCreateFlags(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DescriptorSetLayoutCreateFlags
+operator~(DescriptorSetLayoutCreateFlagBits bits) VULKAN_HPP_NOEXCEPT {
+  return ~(DescriptorSetLayoutCreateFlags(bits));
+}
+
+VULKAN_HPP_INLINE std::string to_string(DescriptorSetLayoutCreateFlags value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & DescriptorSetLayoutCreateFlagBits::eUpdateAfterBindPool)
+    result += "UpdateAfterBindPool | ";
+  if (value & DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR)
+    result += "PushDescriptorKHR | ";
+  if (value & DescriptorSetLayoutCreateFlagBits::eHostOnlyPoolVALVE)
+    result += "HostOnlyPoolVALVE | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+using AccessFlags = Flags<AccessFlagBits>;
+
+template <> struct FlagTraits<AccessFlagBits> {
+  enum : VkFlags {
+    allFlags = VkFlags(AccessFlagBits::eIndirectCommandRead) |
+               VkFlags(AccessFlagBits::eIndexRead) |
+               VkFlags(AccessFlagBits::eVertexAttributeRead) |
+               VkFlags(AccessFlagBits::eUniformRead) |
+               VkFlags(AccessFlagBits::eInputAttachmentRead) |
+               VkFlags(AccessFlagBits::eShaderRead) |
+               VkFlags(AccessFlagBits::eShaderWrite) |
+               VkFlags(AccessFlagBits::eColorAttachmentRead) |
+               VkFlags(AccessFlagBits::eColorAttachmentWrite) |
+               VkFlags(AccessFlagBits::eDepthStencilAttachmentRead) |
+               VkFlags(AccessFlagBits::eDepthStencilAttachmentWrite) |
+               VkFlags(AccessFlagBits::eTransferRead) |
+               VkFlags(AccessFlagBits::eTransferWrite) |
+               VkFlags(AccessFlagBits::eHostRead) |
+               VkFlags(AccessFlagBits::eHostWrite) |
+               VkFlags(AccessFlagBits::eMemoryRead) |
+               VkFlags(AccessFlagBits::eMemoryWrite) |
+               VkFlags(AccessFlagBits::eTransformFeedbackWriteEXT) |
+               VkFlags(AccessFlagBits::eTransformFeedbackCounterReadEXT) |
+               VkFlags(AccessFlagBits::eTransformFeedbackCounterWriteEXT) |
+               VkFlags(AccessFlagBits::eConditionalRenderingReadEXT) |
+               VkFlags(AccessFlagBits::eColorAttachmentReadNoncoherentEXT) |
+               VkFlags(AccessFlagBits::eAccelerationStructureReadKHR) |
+               VkFlags(AccessFlagBits::eAccelerationStructureWriteKHR) |
+               VkFlags(AccessFlagBits::eShadingRateImageReadNV) |
+               VkFlags(AccessFlagBits::eFragmentDensityMapReadEXT) |
+               VkFlags(AccessFlagBits::eCommandPreprocessReadNV) |
+               VkFlags(AccessFlagBits::eCommandPreprocessWriteNV) |
+               VkFlags(AccessFlagBits::eNoneKHR)
+  };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR AccessFlags
+operator|(AccessFlagBits bit0, AccessFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return AccessFlags(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR AccessFlags
+operator&(AccessFlagBits bit0, AccessFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return AccessFlags(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR AccessFlags
+operator^(AccessFlagBits bit0, AccessFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return AccessFlags(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR AccessFlags
+operator~(AccessFlagBits bits) VULKAN_HPP_NOEXCEPT {
+  return ~(AccessFlags(bits));
+}
+
+VULKAN_HPP_INLINE std::string to_string(AccessFlags value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & AccessFlagBits::eIndirectCommandRead)
+    result += "IndirectCommandRead | ";
+  if (value & AccessFlagBits::eIndexRead)
+    result += "IndexRead | ";
+  if (value & AccessFlagBits::eVertexAttributeRead)
+    result += "VertexAttributeRead | ";
+  if (value & AccessFlagBits::eUniformRead)
+    result += "UniformRead | ";
+  if (value & AccessFlagBits::eInputAttachmentRead)
+    result += "InputAttachmentRead | ";
+  if (value & AccessFlagBits::eShaderRead)
+    result += "ShaderRead | ";
+  if (value & AccessFlagBits::eShaderWrite)
+    result += "ShaderWrite | ";
+  if (value & AccessFlagBits::eColorAttachmentRead)
+    result += "ColorAttachmentRead | ";
+  if (value & AccessFlagBits::eColorAttachmentWrite)
+    result += "ColorAttachmentWrite | ";
+  if (value & AccessFlagBits::eDepthStencilAttachmentRead)
+    result += "DepthStencilAttachmentRead | ";
+  if (value & AccessFlagBits::eDepthStencilAttachmentWrite)
+    result += "DepthStencilAttachmentWrite | ";
+  if (value & AccessFlagBits::eTransferRead)
+    result += "TransferRead | ";
+  if (value & AccessFlagBits::eTransferWrite)
+    result += "TransferWrite | ";
+  if (value & AccessFlagBits::eHostRead)
+    result += "HostRead | ";
+  if (value & AccessFlagBits::eHostWrite)
+    result += "HostWrite | ";
+  if (value & AccessFlagBits::eMemoryRead)
+    result += "MemoryRead | ";
+  if (value & AccessFlagBits::eMemoryWrite)
+    result += "MemoryWrite | ";
+  if (value & AccessFlagBits::eTransformFeedbackWriteEXT)
+    result += "TransformFeedbackWriteEXT | ";
+  if (value & AccessFlagBits::eTransformFeedbackCounterReadEXT)
+    result += "TransformFeedbackCounterReadEXT | ";
+  if (value & AccessFlagBits::eTransformFeedbackCounterWriteEXT)
+    result += "TransformFeedbackCounterWriteEXT | ";
+  if (value & AccessFlagBits::eConditionalRenderingReadEXT)
+    result += "ConditionalRenderingReadEXT | ";
+  if (value & AccessFlagBits::eColorAttachmentReadNoncoherentEXT)
+    result += "ColorAttachmentReadNoncoherentEXT | ";
+  if (value & AccessFlagBits::eAccelerationStructureReadKHR)
+    result += "AccelerationStructureReadKHR | ";
+  if (value & AccessFlagBits::eAccelerationStructureWriteKHR)
+    result += "AccelerationStructureWriteKHR | ";
+  if (value & AccessFlagBits::eShadingRateImageReadNV)
+    result += "ShadingRateImageReadNV | ";
+  if (value & AccessFlagBits::eFragmentDensityMapReadEXT)
+    result += "FragmentDensityMapReadEXT | ";
+  if (value & AccessFlagBits::eCommandPreprocessReadNV)
+    result += "CommandPreprocessReadNV | ";
+  if (value & AccessFlagBits::eCommandPreprocessWriteNV)
+    result += "CommandPreprocessWriteNV | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+using AttachmentDescriptionFlags = Flags<AttachmentDescriptionFlagBits>;
+
+template <> struct FlagTraits<AttachmentDescriptionFlagBits> {
+  enum : VkFlags {
+    allFlags = VkFlags(AttachmentDescriptionFlagBits::eMayAlias)
+  };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR AttachmentDescriptionFlags
+operator|(AttachmentDescriptionFlagBits bit0,
+          AttachmentDescriptionFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return AttachmentDescriptionFlags(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR AttachmentDescriptionFlags
+operator&(AttachmentDescriptionFlagBits bit0,
+          AttachmentDescriptionFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return AttachmentDescriptionFlags(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR AttachmentDescriptionFlags
+operator^(AttachmentDescriptionFlagBits bit0,
+          AttachmentDescriptionFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return AttachmentDescriptionFlags(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR AttachmentDescriptionFlags
+operator~(AttachmentDescriptionFlagBits bits) VULKAN_HPP_NOEXCEPT {
+  return ~(AttachmentDescriptionFlags(bits));
+}
+
+VULKAN_HPP_INLINE std::string to_string(AttachmentDescriptionFlags value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & AttachmentDescriptionFlagBits::eMayAlias)
+    result += "MayAlias | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+using DependencyFlags = Flags<DependencyFlagBits>;
+
+template <> struct FlagTraits<DependencyFlagBits> {
+  enum : VkFlags {
+    allFlags = VkFlags(DependencyFlagBits::eByRegion) |
+               VkFlags(DependencyFlagBits::eDeviceGroup) |
+               VkFlags(DependencyFlagBits::eViewLocal)
+  };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DependencyFlags operator|(
+    DependencyFlagBits bit0, DependencyFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return DependencyFlags(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DependencyFlags operator&(
+    DependencyFlagBits bit0, DependencyFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return DependencyFlags(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DependencyFlags operator^(
+    DependencyFlagBits bit0, DependencyFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return DependencyFlags(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DependencyFlags
+operator~(DependencyFlagBits bits) VULKAN_HPP_NOEXCEPT {
+  return ~(DependencyFlags(bits));
+}
+
+VULKAN_HPP_INLINE std::string to_string(DependencyFlags value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & DependencyFlagBits::eByRegion)
+    result += "ByRegion | ";
+  if (value & DependencyFlagBits::eDeviceGroup)
+    result += "DeviceGroup | ";
+  if (value & DependencyFlagBits::eViewLocal)
+    result += "ViewLocal | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+using FramebufferCreateFlags = Flags<FramebufferCreateFlagBits>;
+
+template <> struct FlagTraits<FramebufferCreateFlagBits> {
+  enum : VkFlags { allFlags = VkFlags(FramebufferCreateFlagBits::eImageless) };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR FramebufferCreateFlags
+operator|(FramebufferCreateFlagBits bit0,
+          FramebufferCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return FramebufferCreateFlags(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR FramebufferCreateFlags
+operator&(FramebufferCreateFlagBits bit0,
+          FramebufferCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return FramebufferCreateFlags(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR FramebufferCreateFlags
+operator^(FramebufferCreateFlagBits bit0,
+          FramebufferCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return FramebufferCreateFlags(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR FramebufferCreateFlags
+operator~(FramebufferCreateFlagBits bits) VULKAN_HPP_NOEXCEPT {
+  return ~(FramebufferCreateFlags(bits));
+}
+
+VULKAN_HPP_INLINE std::string to_string(FramebufferCreateFlags value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & FramebufferCreateFlagBits::eImageless)
+    result += "Imageless | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+using RenderPassCreateFlags = Flags<RenderPassCreateFlagBits>;
+
+template <> struct FlagTraits<RenderPassCreateFlagBits> {
+  enum : VkFlags {
+    allFlags = VkFlags(RenderPassCreateFlagBits::eTransformQCOM)
+  };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR RenderPassCreateFlags
+operator|(RenderPassCreateFlagBits bit0,
+          RenderPassCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return RenderPassCreateFlags(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR RenderPassCreateFlags
+operator&(RenderPassCreateFlagBits bit0,
+          RenderPassCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return RenderPassCreateFlags(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR RenderPassCreateFlags
+operator^(RenderPassCreateFlagBits bit0,
+          RenderPassCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return RenderPassCreateFlags(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR RenderPassCreateFlags
+operator~(RenderPassCreateFlagBits bits) VULKAN_HPP_NOEXCEPT {
+  return ~(RenderPassCreateFlags(bits));
+}
+
+VULKAN_HPP_INLINE std::string to_string(RenderPassCreateFlags value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & RenderPassCreateFlagBits::eTransformQCOM)
+    result += "TransformQCOM | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+using SubpassDescriptionFlags = Flags<SubpassDescriptionFlagBits>;
+
+template <> struct FlagTraits<SubpassDescriptionFlagBits> {
+  enum : VkFlags {
+    allFlags = VkFlags(SubpassDescriptionFlagBits::ePerViewAttributesNVX) |
+               VkFlags(SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX) |
+               VkFlags(SubpassDescriptionFlagBits::eFragmentRegionQCOM) |
+               VkFlags(SubpassDescriptionFlagBits::eShaderResolveQCOM)
+  };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SubpassDescriptionFlags
+operator|(SubpassDescriptionFlagBits bit0,
+          SubpassDescriptionFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return SubpassDescriptionFlags(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SubpassDescriptionFlags
+operator&(SubpassDescriptionFlagBits bit0,
+          SubpassDescriptionFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return SubpassDescriptionFlags(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SubpassDescriptionFlags
+operator^(SubpassDescriptionFlagBits bit0,
+          SubpassDescriptionFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return SubpassDescriptionFlags(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SubpassDescriptionFlags
+operator~(SubpassDescriptionFlagBits bits) VULKAN_HPP_NOEXCEPT {
+  return ~(SubpassDescriptionFlags(bits));
+}
+
+VULKAN_HPP_INLINE std::string to_string(SubpassDescriptionFlags value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & SubpassDescriptionFlagBits::ePerViewAttributesNVX)
+    result += "PerViewAttributesNVX | ";
+  if (value & SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX)
+    result += "PerViewPositionXOnlyNVX | ";
+  if (value & SubpassDescriptionFlagBits::eFragmentRegionQCOM)
+    result += "FragmentRegionQCOM | ";
+  if (value & SubpassDescriptionFlagBits::eShaderResolveQCOM)
+    result += "ShaderResolveQCOM | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+using CommandPoolCreateFlags = Flags<CommandPoolCreateFlagBits>;
+
+template <> struct FlagTraits<CommandPoolCreateFlagBits> {
+  enum : VkFlags {
+    allFlags = VkFlags(CommandPoolCreateFlagBits::eTransient) |
+               VkFlags(CommandPoolCreateFlagBits::eResetCommandBuffer) |
+               VkFlags(CommandPoolCreateFlagBits::eProtected)
+  };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CommandPoolCreateFlags
+operator|(CommandPoolCreateFlagBits bit0,
+          CommandPoolCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return CommandPoolCreateFlags(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CommandPoolCreateFlags
+operator&(CommandPoolCreateFlagBits bit0,
+          CommandPoolCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return CommandPoolCreateFlags(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CommandPoolCreateFlags
+operator^(CommandPoolCreateFlagBits bit0,
+          CommandPoolCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return CommandPoolCreateFlags(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CommandPoolCreateFlags
+operator~(CommandPoolCreateFlagBits bits) VULKAN_HPP_NOEXCEPT {
+  return ~(CommandPoolCreateFlags(bits));
+}
+
+VULKAN_HPP_INLINE std::string to_string(CommandPoolCreateFlags value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & CommandPoolCreateFlagBits::eTransient)
+    result += "Transient | ";
+  if (value & CommandPoolCreateFlagBits::eResetCommandBuffer)
+    result += "ResetCommandBuffer | ";
+  if (value & CommandPoolCreateFlagBits::eProtected)
+    result += "Protected | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+using CommandPoolResetFlags = Flags<CommandPoolResetFlagBits>;
+
+template <> struct FlagTraits<CommandPoolResetFlagBits> {
+  enum : VkFlags {
+    allFlags = VkFlags(CommandPoolResetFlagBits::eReleaseResources)
+  };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CommandPoolResetFlags
+operator|(CommandPoolResetFlagBits bit0,
+          CommandPoolResetFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return CommandPoolResetFlags(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CommandPoolResetFlags
+operator&(CommandPoolResetFlagBits bit0,
+          CommandPoolResetFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return CommandPoolResetFlags(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CommandPoolResetFlags
+operator^(CommandPoolResetFlagBits bit0,
+          CommandPoolResetFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return CommandPoolResetFlags(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CommandPoolResetFlags
+operator~(CommandPoolResetFlagBits bits) VULKAN_HPP_NOEXCEPT {
+  return ~(CommandPoolResetFlags(bits));
+}
+
+VULKAN_HPP_INLINE std::string to_string(CommandPoolResetFlags value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & CommandPoolResetFlagBits::eReleaseResources)
+    result += "ReleaseResources | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+using CommandBufferResetFlags = Flags<CommandBufferResetFlagBits>;
+
+template <> struct FlagTraits<CommandBufferResetFlagBits> {
+  enum : VkFlags {
+    allFlags = VkFlags(CommandBufferResetFlagBits::eReleaseResources)
+  };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CommandBufferResetFlags
+operator|(CommandBufferResetFlagBits bit0,
+          CommandBufferResetFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return CommandBufferResetFlags(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CommandBufferResetFlags
+operator&(CommandBufferResetFlagBits bit0,
+          CommandBufferResetFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return CommandBufferResetFlags(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CommandBufferResetFlags
+operator^(CommandBufferResetFlagBits bit0,
+          CommandBufferResetFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return CommandBufferResetFlags(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CommandBufferResetFlags
+operator~(CommandBufferResetFlagBits bits) VULKAN_HPP_NOEXCEPT {
+  return ~(CommandBufferResetFlags(bits));
+}
+
+VULKAN_HPP_INLINE std::string to_string(CommandBufferResetFlags value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & CommandBufferResetFlagBits::eReleaseResources)
+    result += "ReleaseResources | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+using CommandBufferUsageFlags = Flags<CommandBufferUsageFlagBits>;
+
+template <> struct FlagTraits<CommandBufferUsageFlagBits> {
+  enum : VkFlags {
+    allFlags = VkFlags(CommandBufferUsageFlagBits::eOneTimeSubmit) |
+               VkFlags(CommandBufferUsageFlagBits::eRenderPassContinue) |
+               VkFlags(CommandBufferUsageFlagBits::eSimultaneousUse)
+  };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CommandBufferUsageFlags
+operator|(CommandBufferUsageFlagBits bit0,
+          CommandBufferUsageFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return CommandBufferUsageFlags(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CommandBufferUsageFlags
+operator&(CommandBufferUsageFlagBits bit0,
+          CommandBufferUsageFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return CommandBufferUsageFlags(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CommandBufferUsageFlags
+operator^(CommandBufferUsageFlagBits bit0,
+          CommandBufferUsageFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return CommandBufferUsageFlags(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CommandBufferUsageFlags
+operator~(CommandBufferUsageFlagBits bits) VULKAN_HPP_NOEXCEPT {
+  return ~(CommandBufferUsageFlags(bits));
+}
+
+VULKAN_HPP_INLINE std::string to_string(CommandBufferUsageFlags value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & CommandBufferUsageFlagBits::eOneTimeSubmit)
+    result += "OneTimeSubmit | ";
+  if (value & CommandBufferUsageFlagBits::eRenderPassContinue)
+    result += "RenderPassContinue | ";
+  if (value & CommandBufferUsageFlagBits::eSimultaneousUse)
+    result += "SimultaneousUse | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+using QueryControlFlags = Flags<QueryControlFlagBits>;
+
+template <> struct FlagTraits<QueryControlFlagBits> {
+  enum : VkFlags { allFlags = VkFlags(QueryControlFlagBits::ePrecise) };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR QueryControlFlags operator|(
+    QueryControlFlagBits bit0, QueryControlFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return QueryControlFlags(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR QueryControlFlags operator&(
+    QueryControlFlagBits bit0, QueryControlFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return QueryControlFlags(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR QueryControlFlags operator^(
+    QueryControlFlagBits bit0, QueryControlFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return QueryControlFlags(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR QueryControlFlags
+operator~(QueryControlFlagBits bits) VULKAN_HPP_NOEXCEPT {
+  return ~(QueryControlFlags(bits));
+}
+
+VULKAN_HPP_INLINE std::string to_string(QueryControlFlags value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & QueryControlFlagBits::ePrecise)
+    result += "Precise | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+using StencilFaceFlags = Flags<StencilFaceFlagBits>;
+
+template <> struct FlagTraits<StencilFaceFlagBits> {
+  enum : VkFlags {
+    allFlags = VkFlags(StencilFaceFlagBits::eFront) |
+               VkFlags(StencilFaceFlagBits::eBack) |
+               VkFlags(StencilFaceFlagBits::eFrontAndBack)
+  };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR StencilFaceFlags operator|(
+    StencilFaceFlagBits bit0, StencilFaceFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return StencilFaceFlags(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR StencilFaceFlags operator&(
+    StencilFaceFlagBits bit0, StencilFaceFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return StencilFaceFlags(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR StencilFaceFlags operator^(
+    StencilFaceFlagBits bit0, StencilFaceFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return StencilFaceFlags(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR StencilFaceFlags
+operator~(StencilFaceFlagBits bits) VULKAN_HPP_NOEXCEPT {
+  return ~(StencilFaceFlags(bits));
+}
+
+VULKAN_HPP_INLINE std::string to_string(StencilFaceFlags value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & StencilFaceFlagBits::eFront)
+    result += "Front | ";
+  if (value & StencilFaceFlagBits::eBack)
+    result += "Back | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+//=== VK_VERSION_1_1 ===
+
+using SubgroupFeatureFlags = Flags<SubgroupFeatureFlagBits>;
+
+template <> struct FlagTraits<SubgroupFeatureFlagBits> {
+  enum : VkFlags {
+    allFlags = VkFlags(SubgroupFeatureFlagBits::eBasic) |
+               VkFlags(SubgroupFeatureFlagBits::eVote) |
+               VkFlags(SubgroupFeatureFlagBits::eArithmetic) |
+               VkFlags(SubgroupFeatureFlagBits::eBallot) |
+               VkFlags(SubgroupFeatureFlagBits::eShuffle) |
+               VkFlags(SubgroupFeatureFlagBits::eShuffleRelative) |
+               VkFlags(SubgroupFeatureFlagBits::eClustered) |
+               VkFlags(SubgroupFeatureFlagBits::eQuad) |
+               VkFlags(SubgroupFeatureFlagBits::ePartitionedNV)
+  };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SubgroupFeatureFlags
+operator|(SubgroupFeatureFlagBits bit0,
+          SubgroupFeatureFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return SubgroupFeatureFlags(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SubgroupFeatureFlags
+operator&(SubgroupFeatureFlagBits bit0,
+          SubgroupFeatureFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return SubgroupFeatureFlags(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SubgroupFeatureFlags
+operator^(SubgroupFeatureFlagBits bit0,
+          SubgroupFeatureFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return SubgroupFeatureFlags(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SubgroupFeatureFlags
+operator~(SubgroupFeatureFlagBits bits) VULKAN_HPP_NOEXCEPT {
+  return ~(SubgroupFeatureFlags(bits));
+}
+
+VULKAN_HPP_INLINE std::string to_string(SubgroupFeatureFlags value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & SubgroupFeatureFlagBits::eBasic)
+    result += "Basic | ";
+  if (value & SubgroupFeatureFlagBits::eVote)
+    result += "Vote | ";
+  if (value & SubgroupFeatureFlagBits::eArithmetic)
+    result += "Arithmetic | ";
+  if (value & SubgroupFeatureFlagBits::eBallot)
+    result += "Ballot | ";
+  if (value & SubgroupFeatureFlagBits::eShuffle)
+    result += "Shuffle | ";
+  if (value & SubgroupFeatureFlagBits::eShuffleRelative)
+    result += "ShuffleRelative | ";
+  if (value & SubgroupFeatureFlagBits::eClustered)
+    result += "Clustered | ";
+  if (value & SubgroupFeatureFlagBits::eQuad)
+    result += "Quad | ";
+  if (value & SubgroupFeatureFlagBits::ePartitionedNV)
+    result += "PartitionedNV | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+using PeerMemoryFeatureFlags = Flags<PeerMemoryFeatureFlagBits>;
+
+template <> struct FlagTraits<PeerMemoryFeatureFlagBits> {
+  enum : VkFlags {
+    allFlags = VkFlags(PeerMemoryFeatureFlagBits::eCopySrc) |
+               VkFlags(PeerMemoryFeatureFlagBits::eCopyDst) |
+               VkFlags(PeerMemoryFeatureFlagBits::eGenericSrc) |
+               VkFlags(PeerMemoryFeatureFlagBits::eGenericDst)
+  };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PeerMemoryFeatureFlags
+operator|(PeerMemoryFeatureFlagBits bit0,
+          PeerMemoryFeatureFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return PeerMemoryFeatureFlags(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PeerMemoryFeatureFlags
+operator&(PeerMemoryFeatureFlagBits bit0,
+          PeerMemoryFeatureFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return PeerMemoryFeatureFlags(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PeerMemoryFeatureFlags
+operator^(PeerMemoryFeatureFlagBits bit0,
+          PeerMemoryFeatureFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return PeerMemoryFeatureFlags(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PeerMemoryFeatureFlags
+operator~(PeerMemoryFeatureFlagBits bits) VULKAN_HPP_NOEXCEPT {
+  return ~(PeerMemoryFeatureFlags(bits));
+}
+
+using PeerMemoryFeatureFlagsKHR = PeerMemoryFeatureFlags;
+
+VULKAN_HPP_INLINE std::string to_string(PeerMemoryFeatureFlags value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & PeerMemoryFeatureFlagBits::eCopySrc)
+    result += "CopySrc | ";
+  if (value & PeerMemoryFeatureFlagBits::eCopyDst)
+    result += "CopyDst | ";
+  if (value & PeerMemoryFeatureFlagBits::eGenericSrc)
+    result += "GenericSrc | ";
+  if (value & PeerMemoryFeatureFlagBits::eGenericDst)
+    result += "GenericDst | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+using MemoryAllocateFlags = Flags<MemoryAllocateFlagBits>;
+
+template <> struct FlagTraits<MemoryAllocateFlagBits> {
+  enum : VkFlags {
+    allFlags = VkFlags(MemoryAllocateFlagBits::eDeviceMask) |
+               VkFlags(MemoryAllocateFlagBits::eDeviceAddress) |
+               VkFlags(MemoryAllocateFlagBits::eDeviceAddressCaptureReplay)
+  };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR MemoryAllocateFlags
+operator|(MemoryAllocateFlagBits bit0,
+          MemoryAllocateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return MemoryAllocateFlags(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR MemoryAllocateFlags
+operator&(MemoryAllocateFlagBits bit0,
+          MemoryAllocateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return MemoryAllocateFlags(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR MemoryAllocateFlags
+operator^(MemoryAllocateFlagBits bit0,
+          MemoryAllocateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return MemoryAllocateFlags(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR MemoryAllocateFlags
+operator~(MemoryAllocateFlagBits bits) VULKAN_HPP_NOEXCEPT {
+  return ~(MemoryAllocateFlags(bits));
+}
+
+using MemoryAllocateFlagsKHR = MemoryAllocateFlags;
+
+VULKAN_HPP_INLINE std::string to_string(MemoryAllocateFlags value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & MemoryAllocateFlagBits::eDeviceMask)
+    result += "DeviceMask | ";
+  if (value & MemoryAllocateFlagBits::eDeviceAddress)
+    result += "DeviceAddress | ";
+  if (value & MemoryAllocateFlagBits::eDeviceAddressCaptureReplay)
+    result += "DeviceAddressCaptureReplay | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+enum class CommandPoolTrimFlagBits : VkFlags {};
+
+VULKAN_HPP_INLINE std::string to_string(CommandPoolTrimFlagBits) {
+  return "(void)";
+}
+
+using CommandPoolTrimFlags = Flags<CommandPoolTrimFlagBits>;
+
+using CommandPoolTrimFlagsKHR = CommandPoolTrimFlags;
+
+VULKAN_HPP_INLINE std::string to_string(CommandPoolTrimFlags) { return "{}"; }
+
+enum class DescriptorUpdateTemplateCreateFlagBits : VkFlags {};
+
+VULKAN_HPP_INLINE std::string
+to_string(DescriptorUpdateTemplateCreateFlagBits) {
+  return "(void)";
+}
+
+using DescriptorUpdateTemplateCreateFlags =
+    Flags<DescriptorUpdateTemplateCreateFlagBits>;
+
+using DescriptorUpdateTemplateCreateFlagsKHR =
+    DescriptorUpdateTemplateCreateFlags;
+
+VULKAN_HPP_INLINE std::string to_string(DescriptorUpdateTemplateCreateFlags) {
+  return "{}";
+}
+
+using ExternalMemoryHandleTypeFlags = Flags<ExternalMemoryHandleTypeFlagBits>;
+
+template <> struct FlagTraits<ExternalMemoryHandleTypeFlagBits> {
+  enum : VkFlags {
+    allFlags =
+        VkFlags(ExternalMemoryHandleTypeFlagBits::eOpaqueFd) |
+        VkFlags(ExternalMemoryHandleTypeFlagBits::eOpaqueWin32) |
+        VkFlags(ExternalMemoryHandleTypeFlagBits::eOpaqueWin32Kmt) |
+        VkFlags(ExternalMemoryHandleTypeFlagBits::eD3D11Texture) |
+        VkFlags(ExternalMemoryHandleTypeFlagBits::eD3D11TextureKmt) |
+        VkFlags(ExternalMemoryHandleTypeFlagBits::eD3D12Heap) |
+        VkFlags(ExternalMemoryHandleTypeFlagBits::eD3D12Resource) |
+        VkFlags(ExternalMemoryHandleTypeFlagBits::eDmaBufEXT)
+#if defined(VK_USE_PLATFORM_ANDROID_KHR)
+        |
+        VkFlags(ExternalMemoryHandleTypeFlagBits::eAndroidHardwareBufferANDROID)
+#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+        | VkFlags(ExternalMemoryHandleTypeFlagBits::eHostAllocationEXT) |
+        VkFlags(ExternalMemoryHandleTypeFlagBits::eHostMappedForeignMemoryEXT)
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+        | VkFlags(ExternalMemoryHandleTypeFlagBits::eZirconVmoFUCHSIA)
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+  };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalMemoryHandleTypeFlags
+operator|(ExternalMemoryHandleTypeFlagBits bit0,
+          ExternalMemoryHandleTypeFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return ExternalMemoryHandleTypeFlags(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalMemoryHandleTypeFlags
+operator&(ExternalMemoryHandleTypeFlagBits bit0,
+          ExternalMemoryHandleTypeFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return ExternalMemoryHandleTypeFlags(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalMemoryHandleTypeFlags
+operator^(ExternalMemoryHandleTypeFlagBits bit0,
+          ExternalMemoryHandleTypeFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return ExternalMemoryHandleTypeFlags(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalMemoryHandleTypeFlags
+operator~(ExternalMemoryHandleTypeFlagBits bits) VULKAN_HPP_NOEXCEPT {
+  return ~(ExternalMemoryHandleTypeFlags(bits));
+}
+
+using ExternalMemoryHandleTypeFlagsKHR = ExternalMemoryHandleTypeFlags;
+
+VULKAN_HPP_INLINE std::string to_string(ExternalMemoryHandleTypeFlags value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & ExternalMemoryHandleTypeFlagBits::eOpaqueFd)
+    result += "OpaqueFd | ";
+  if (value & ExternalMemoryHandleTypeFlagBits::eOpaqueWin32)
+    result += "OpaqueWin32 | ";
+  if (value & ExternalMemoryHandleTypeFlagBits::eOpaqueWin32Kmt)
+    result += "OpaqueWin32Kmt | ";
+  if (value & ExternalMemoryHandleTypeFlagBits::eD3D11Texture)
+    result += "D3D11Texture | ";
+  if (value & ExternalMemoryHandleTypeFlagBits::eD3D11TextureKmt)
+    result += "D3D11TextureKmt | ";
+  if (value & ExternalMemoryHandleTypeFlagBits::eD3D12Heap)
+    result += "D3D12Heap | ";
+  if (value & ExternalMemoryHandleTypeFlagBits::eD3D12Resource)
+    result += "D3D12Resource | ";
+  if (value & ExternalMemoryHandleTypeFlagBits::eDmaBufEXT)
+    result += "DmaBufEXT | ";
+#if defined(VK_USE_PLATFORM_ANDROID_KHR)
+  if (value & ExternalMemoryHandleTypeFlagBits::eAndroidHardwareBufferANDROID)
+    result += "AndroidHardwareBufferANDROID | ";
+#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+  if (value & ExternalMemoryHandleTypeFlagBits::eHostAllocationEXT)
+    result += "HostAllocationEXT | ";
+  if (value & ExternalMemoryHandleTypeFlagBits::eHostMappedForeignMemoryEXT)
+    result += "HostMappedForeignMemoryEXT | ";
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+  if (value & ExternalMemoryHandleTypeFlagBits::eZirconVmoFUCHSIA)
+    result += "ZirconVmoFUCHSIA | ";
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+using ExternalMemoryFeatureFlags = Flags<ExternalMemoryFeatureFlagBits>;
+
+template <> struct FlagTraits<ExternalMemoryFeatureFlagBits> {
+  enum : VkFlags {
+    allFlags = VkFlags(ExternalMemoryFeatureFlagBits::eDedicatedOnly) |
+               VkFlags(ExternalMemoryFeatureFlagBits::eExportable) |
+               VkFlags(ExternalMemoryFeatureFlagBits::eImportable)
+  };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalMemoryFeatureFlags
+operator|(ExternalMemoryFeatureFlagBits bit0,
+          ExternalMemoryFeatureFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return ExternalMemoryFeatureFlags(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalMemoryFeatureFlags
+operator&(ExternalMemoryFeatureFlagBits bit0,
+          ExternalMemoryFeatureFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return ExternalMemoryFeatureFlags(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalMemoryFeatureFlags
+operator^(ExternalMemoryFeatureFlagBits bit0,
+          ExternalMemoryFeatureFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return ExternalMemoryFeatureFlags(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalMemoryFeatureFlags
+operator~(ExternalMemoryFeatureFlagBits bits) VULKAN_HPP_NOEXCEPT {
+  return ~(ExternalMemoryFeatureFlags(bits));
+}
+
+using ExternalMemoryFeatureFlagsKHR = ExternalMemoryFeatureFlags;
+
+VULKAN_HPP_INLINE std::string to_string(ExternalMemoryFeatureFlags value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & ExternalMemoryFeatureFlagBits::eDedicatedOnly)
+    result += "DedicatedOnly | ";
+  if (value & ExternalMemoryFeatureFlagBits::eExportable)
+    result += "Exportable | ";
+  if (value & ExternalMemoryFeatureFlagBits::eImportable)
+    result += "Importable | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+using ExternalFenceHandleTypeFlags = Flags<ExternalFenceHandleTypeFlagBits>;
+
+template <> struct FlagTraits<ExternalFenceHandleTypeFlagBits> {
+  enum : VkFlags {
+    allFlags = VkFlags(ExternalFenceHandleTypeFlagBits::eOpaqueFd) |
+               VkFlags(ExternalFenceHandleTypeFlagBits::eOpaqueWin32) |
+               VkFlags(ExternalFenceHandleTypeFlagBits::eOpaqueWin32Kmt) |
+               VkFlags(ExternalFenceHandleTypeFlagBits::eSyncFd)
+  };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalFenceHandleTypeFlags
+operator|(ExternalFenceHandleTypeFlagBits bit0,
+          ExternalFenceHandleTypeFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return ExternalFenceHandleTypeFlags(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalFenceHandleTypeFlags
+operator&(ExternalFenceHandleTypeFlagBits bit0,
+          ExternalFenceHandleTypeFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return ExternalFenceHandleTypeFlags(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalFenceHandleTypeFlags
+operator^(ExternalFenceHandleTypeFlagBits bit0,
+          ExternalFenceHandleTypeFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return ExternalFenceHandleTypeFlags(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalFenceHandleTypeFlags
+operator~(ExternalFenceHandleTypeFlagBits bits) VULKAN_HPP_NOEXCEPT {
+  return ~(ExternalFenceHandleTypeFlags(bits));
+}
+
+using ExternalFenceHandleTypeFlagsKHR = ExternalFenceHandleTypeFlags;
+
+VULKAN_HPP_INLINE std::string to_string(ExternalFenceHandleTypeFlags value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & ExternalFenceHandleTypeFlagBits::eOpaqueFd)
+    result += "OpaqueFd | ";
+  if (value & ExternalFenceHandleTypeFlagBits::eOpaqueWin32)
+    result += "OpaqueWin32 | ";
+  if (value & ExternalFenceHandleTypeFlagBits::eOpaqueWin32Kmt)
+    result += "OpaqueWin32Kmt | ";
+  if (value & ExternalFenceHandleTypeFlagBits::eSyncFd)
+    result += "SyncFd | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+using ExternalFenceFeatureFlags = Flags<ExternalFenceFeatureFlagBits>;
+
+template <> struct FlagTraits<ExternalFenceFeatureFlagBits> {
+  enum : VkFlags {
+    allFlags = VkFlags(ExternalFenceFeatureFlagBits::eExportable) |
+               VkFlags(ExternalFenceFeatureFlagBits::eImportable)
+  };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalFenceFeatureFlags
+operator|(ExternalFenceFeatureFlagBits bit0,
+          ExternalFenceFeatureFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return ExternalFenceFeatureFlags(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalFenceFeatureFlags
+operator&(ExternalFenceFeatureFlagBits bit0,
+          ExternalFenceFeatureFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return ExternalFenceFeatureFlags(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalFenceFeatureFlags
+operator^(ExternalFenceFeatureFlagBits bit0,
+          ExternalFenceFeatureFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return ExternalFenceFeatureFlags(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalFenceFeatureFlags
+operator~(ExternalFenceFeatureFlagBits bits) VULKAN_HPP_NOEXCEPT {
+  return ~(ExternalFenceFeatureFlags(bits));
+}
+
+using ExternalFenceFeatureFlagsKHR = ExternalFenceFeatureFlags;
+
+VULKAN_HPP_INLINE std::string to_string(ExternalFenceFeatureFlags value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & ExternalFenceFeatureFlagBits::eExportable)
+    result += "Exportable | ";
+  if (value & ExternalFenceFeatureFlagBits::eImportable)
+    result += "Importable | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+using FenceImportFlags = Flags<FenceImportFlagBits>;
+
+template <> struct FlagTraits<FenceImportFlagBits> {
+  enum : VkFlags { allFlags = VkFlags(FenceImportFlagBits::eTemporary) };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR FenceImportFlags operator|(
+    FenceImportFlagBits bit0, FenceImportFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return FenceImportFlags(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR FenceImportFlags operator&(
+    FenceImportFlagBits bit0, FenceImportFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return FenceImportFlags(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR FenceImportFlags operator^(
+    FenceImportFlagBits bit0, FenceImportFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return FenceImportFlags(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR FenceImportFlags
+operator~(FenceImportFlagBits bits) VULKAN_HPP_NOEXCEPT {
+  return ~(FenceImportFlags(bits));
+}
+
+using FenceImportFlagsKHR = FenceImportFlags;
+
+VULKAN_HPP_INLINE std::string to_string(FenceImportFlags value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & FenceImportFlagBits::eTemporary)
+    result += "Temporary | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+using SemaphoreImportFlags = Flags<SemaphoreImportFlagBits>;
+
+template <> struct FlagTraits<SemaphoreImportFlagBits> {
+  enum : VkFlags { allFlags = VkFlags(SemaphoreImportFlagBits::eTemporary) };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SemaphoreImportFlags
+operator|(SemaphoreImportFlagBits bit0,
+          SemaphoreImportFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return SemaphoreImportFlags(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SemaphoreImportFlags
+operator&(SemaphoreImportFlagBits bit0,
+          SemaphoreImportFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return SemaphoreImportFlags(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SemaphoreImportFlags
+operator^(SemaphoreImportFlagBits bit0,
+          SemaphoreImportFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return SemaphoreImportFlags(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SemaphoreImportFlags
+operator~(SemaphoreImportFlagBits bits) VULKAN_HPP_NOEXCEPT {
+  return ~(SemaphoreImportFlags(bits));
+}
+
+using SemaphoreImportFlagsKHR = SemaphoreImportFlags;
+
+VULKAN_HPP_INLINE std::string to_string(SemaphoreImportFlags value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & SemaphoreImportFlagBits::eTemporary)
+    result += "Temporary | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+using ExternalSemaphoreHandleTypeFlags =
+    Flags<ExternalSemaphoreHandleTypeFlagBits>;
+
+template <> struct FlagTraits<ExternalSemaphoreHandleTypeFlagBits> {
+  enum : VkFlags {
+    allFlags = VkFlags(ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd) |
+               VkFlags(ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32) |
+               VkFlags(ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32Kmt) |
+               VkFlags(ExternalSemaphoreHandleTypeFlagBits::eD3D12Fence) |
+               VkFlags(ExternalSemaphoreHandleTypeFlagBits::eSyncFd)
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+               |
+               VkFlags(ExternalSemaphoreHandleTypeFlagBits::eZirconEventFUCHSIA)
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+  };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalSemaphoreHandleTypeFlags
+operator|(ExternalSemaphoreHandleTypeFlagBits bit0,
+          ExternalSemaphoreHandleTypeFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return ExternalSemaphoreHandleTypeFlags(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalSemaphoreHandleTypeFlags
+operator&(ExternalSemaphoreHandleTypeFlagBits bit0,
+          ExternalSemaphoreHandleTypeFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return ExternalSemaphoreHandleTypeFlags(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalSemaphoreHandleTypeFlags
+operator^(ExternalSemaphoreHandleTypeFlagBits bit0,
+          ExternalSemaphoreHandleTypeFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return ExternalSemaphoreHandleTypeFlags(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalSemaphoreHandleTypeFlags
+operator~(ExternalSemaphoreHandleTypeFlagBits bits) VULKAN_HPP_NOEXCEPT {
+  return ~(ExternalSemaphoreHandleTypeFlags(bits));
+}
+
+using ExternalSemaphoreHandleTypeFlagsKHR = ExternalSemaphoreHandleTypeFlags;
+
+VULKAN_HPP_INLINE std::string
+to_string(ExternalSemaphoreHandleTypeFlags value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd)
+    result += "OpaqueFd | ";
+  if (value & ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32)
+    result += "OpaqueWin32 | ";
+  if (value & ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32Kmt)
+    result += "OpaqueWin32Kmt | ";
+  if (value & ExternalSemaphoreHandleTypeFlagBits::eD3D12Fence)
+    result += "D3D12Fence | ";
+  if (value & ExternalSemaphoreHandleTypeFlagBits::eSyncFd)
+    result += "SyncFd | ";
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+  if (value & ExternalSemaphoreHandleTypeFlagBits::eZirconEventFUCHSIA)
+    result += "ZirconEventFUCHSIA | ";
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+using ExternalSemaphoreFeatureFlags = Flags<ExternalSemaphoreFeatureFlagBits>;
+
+template <> struct FlagTraits<ExternalSemaphoreFeatureFlagBits> {
+  enum : VkFlags {
+    allFlags = VkFlags(ExternalSemaphoreFeatureFlagBits::eExportable) |
+               VkFlags(ExternalSemaphoreFeatureFlagBits::eImportable)
+  };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalSemaphoreFeatureFlags
+operator|(ExternalSemaphoreFeatureFlagBits bit0,
+          ExternalSemaphoreFeatureFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return ExternalSemaphoreFeatureFlags(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalSemaphoreFeatureFlags
+operator&(ExternalSemaphoreFeatureFlagBits bit0,
+          ExternalSemaphoreFeatureFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return ExternalSemaphoreFeatureFlags(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalSemaphoreFeatureFlags
+operator^(ExternalSemaphoreFeatureFlagBits bit0,
+          ExternalSemaphoreFeatureFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return ExternalSemaphoreFeatureFlags(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalSemaphoreFeatureFlags
+operator~(ExternalSemaphoreFeatureFlagBits bits) VULKAN_HPP_NOEXCEPT {
+  return ~(ExternalSemaphoreFeatureFlags(bits));
+}
+
+using ExternalSemaphoreFeatureFlagsKHR = ExternalSemaphoreFeatureFlags;
+
+VULKAN_HPP_INLINE std::string to_string(ExternalSemaphoreFeatureFlags value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & ExternalSemaphoreFeatureFlagBits::eExportable)
+    result += "Exportable | ";
+  if (value & ExternalSemaphoreFeatureFlagBits::eImportable)
+    result += "Importable | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+//=== VK_VERSION_1_2 ===
+
+using DescriptorBindingFlags = Flags<DescriptorBindingFlagBits>;
+
+template <> struct FlagTraits<DescriptorBindingFlagBits> {
+  enum : VkFlags {
+    allFlags = VkFlags(DescriptorBindingFlagBits::eUpdateAfterBind) |
+               VkFlags(DescriptorBindingFlagBits::eUpdateUnusedWhilePending) |
+               VkFlags(DescriptorBindingFlagBits::ePartiallyBound) |
+               VkFlags(DescriptorBindingFlagBits::eVariableDescriptorCount)
+  };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DescriptorBindingFlags
+operator|(DescriptorBindingFlagBits bit0,
+          DescriptorBindingFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return DescriptorBindingFlags(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DescriptorBindingFlags
+operator&(DescriptorBindingFlagBits bit0,
+          DescriptorBindingFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return DescriptorBindingFlags(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DescriptorBindingFlags
+operator^(DescriptorBindingFlagBits bit0,
+          DescriptorBindingFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return DescriptorBindingFlags(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DescriptorBindingFlags
+operator~(DescriptorBindingFlagBits bits) VULKAN_HPP_NOEXCEPT {
+  return ~(DescriptorBindingFlags(bits));
+}
+
+using DescriptorBindingFlagsEXT = DescriptorBindingFlags;
+
+VULKAN_HPP_INLINE std::string to_string(DescriptorBindingFlags value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & DescriptorBindingFlagBits::eUpdateAfterBind)
+    result += "UpdateAfterBind | ";
+  if (value & DescriptorBindingFlagBits::eUpdateUnusedWhilePending)
+    result += "UpdateUnusedWhilePending | ";
+  if (value & DescriptorBindingFlagBits::ePartiallyBound)
+    result += "PartiallyBound | ";
+  if (value & DescriptorBindingFlagBits::eVariableDescriptorCount)
+    result += "VariableDescriptorCount | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+using ResolveModeFlags = Flags<ResolveModeFlagBits>;
+
+template <> struct FlagTraits<ResolveModeFlagBits> {
+  enum : VkFlags {
+    allFlags = VkFlags(ResolveModeFlagBits::eNone) |
+               VkFlags(ResolveModeFlagBits::eSampleZero) |
+               VkFlags(ResolveModeFlagBits::eAverage) |
+               VkFlags(ResolveModeFlagBits::eMin) |
+               VkFlags(ResolveModeFlagBits::eMax)
+  };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ResolveModeFlags operator|(
+    ResolveModeFlagBits bit0, ResolveModeFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return ResolveModeFlags(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ResolveModeFlags operator&(
+    ResolveModeFlagBits bit0, ResolveModeFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return ResolveModeFlags(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ResolveModeFlags operator^(
+    ResolveModeFlagBits bit0, ResolveModeFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return ResolveModeFlags(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ResolveModeFlags
+operator~(ResolveModeFlagBits bits) VULKAN_HPP_NOEXCEPT {
+  return ~(ResolveModeFlags(bits));
+}
+
+using ResolveModeFlagsKHR = ResolveModeFlags;
+
+VULKAN_HPP_INLINE std::string to_string(ResolveModeFlags value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & ResolveModeFlagBits::eSampleZero)
+    result += "SampleZero | ";
+  if (value & ResolveModeFlagBits::eAverage)
+    result += "Average | ";
+  if (value & ResolveModeFlagBits::eMin)
+    result += "Min | ";
+  if (value & ResolveModeFlagBits::eMax)
+    result += "Max | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+using SemaphoreWaitFlags = Flags<SemaphoreWaitFlagBits>;
+
+template <> struct FlagTraits<SemaphoreWaitFlagBits> {
+  enum : VkFlags { allFlags = VkFlags(SemaphoreWaitFlagBits::eAny) };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SemaphoreWaitFlags
+operator|(SemaphoreWaitFlagBits bit0,
+          SemaphoreWaitFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return SemaphoreWaitFlags(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SemaphoreWaitFlags
+operator&(SemaphoreWaitFlagBits bit0,
+          SemaphoreWaitFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return SemaphoreWaitFlags(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SemaphoreWaitFlags
+operator^(SemaphoreWaitFlagBits bit0,
+          SemaphoreWaitFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+  return SemaphoreWaitFlags(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SemaphoreWaitFlags
+operator~(SemaphoreWaitFlagBits bits) VULKAN_HPP_NOEXCEPT {
+  return ~(SemaphoreWaitFlags(bits));
+}
+
+using SemaphoreWaitFlagsKHR = SemaphoreWaitFlags;
+
+VULKAN_HPP_INLINE std::string to_string(SemaphoreWaitFlags value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & SemaphoreWaitFlagBits::eAny)
+    result += "Any | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+//=== VK_KHR_surface ===
+
+using CompositeAlphaFlagsKHR = Flags<CompositeAlphaFlagBitsKHR>;
+
+template <> struct FlagTraits<CompositeAlphaFlagBitsKHR> {
+  enum : VkFlags {
+    allFlags = VkFlags(CompositeAlphaFlagBitsKHR::eOpaque) |
+               VkFlags(CompositeAlphaFlagBitsKHR::ePreMultiplied) |
+               VkFlags(CompositeAlphaFlagBitsKHR::ePostMultiplied) |
+               VkFlags(CompositeAlphaFlagBitsKHR::eInherit)
+  };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CompositeAlphaFlagsKHR
+operator|(CompositeAlphaFlagBitsKHR bit0,
+          CompositeAlphaFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
+  return CompositeAlphaFlagsKHR(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CompositeAlphaFlagsKHR
+operator&(CompositeAlphaFlagBitsKHR bit0,
+          CompositeAlphaFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
+  return CompositeAlphaFlagsKHR(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CompositeAlphaFlagsKHR
+operator^(CompositeAlphaFlagBitsKHR bit0,
+          CompositeAlphaFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
+  return CompositeAlphaFlagsKHR(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CompositeAlphaFlagsKHR
+operator~(CompositeAlphaFlagBitsKHR bits) VULKAN_HPP_NOEXCEPT {
+  return ~(CompositeAlphaFlagsKHR(bits));
+}
+
+VULKAN_HPP_INLINE std::string to_string(CompositeAlphaFlagsKHR value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & CompositeAlphaFlagBitsKHR::eOpaque)
+    result += "Opaque | ";
+  if (value & CompositeAlphaFlagBitsKHR::ePreMultiplied)
+    result += "PreMultiplied | ";
+  if (value & CompositeAlphaFlagBitsKHR::ePostMultiplied)
+    result += "PostMultiplied | ";
+  if (value & CompositeAlphaFlagBitsKHR::eInherit)
+    result += "Inherit | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+//=== VK_KHR_swapchain ===
+
+using SwapchainCreateFlagsKHR = Flags<SwapchainCreateFlagBitsKHR>;
+
+template <> struct FlagTraits<SwapchainCreateFlagBitsKHR> {
+  enum : VkFlags {
+    allFlags = VkFlags(SwapchainCreateFlagBitsKHR::eSplitInstanceBindRegions) |
+               VkFlags(SwapchainCreateFlagBitsKHR::eProtected) |
+               VkFlags(SwapchainCreateFlagBitsKHR::eMutableFormat)
+  };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SwapchainCreateFlagsKHR
+operator|(SwapchainCreateFlagBitsKHR bit0,
+          SwapchainCreateFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
+  return SwapchainCreateFlagsKHR(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SwapchainCreateFlagsKHR
+operator&(SwapchainCreateFlagBitsKHR bit0,
+          SwapchainCreateFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
+  return SwapchainCreateFlagsKHR(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SwapchainCreateFlagsKHR
+operator^(SwapchainCreateFlagBitsKHR bit0,
+          SwapchainCreateFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
+  return SwapchainCreateFlagsKHR(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SwapchainCreateFlagsKHR
+operator~(SwapchainCreateFlagBitsKHR bits) VULKAN_HPP_NOEXCEPT {
+  return ~(SwapchainCreateFlagsKHR(bits));
+}
+
+VULKAN_HPP_INLINE std::string to_string(SwapchainCreateFlagsKHR value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & SwapchainCreateFlagBitsKHR::eSplitInstanceBindRegions)
+    result += "SplitInstanceBindRegions | ";
+  if (value & SwapchainCreateFlagBitsKHR::eProtected)
+    result += "Protected | ";
+  if (value & SwapchainCreateFlagBitsKHR::eMutableFormat)
+    result += "MutableFormat | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+using DeviceGroupPresentModeFlagsKHR = Flags<DeviceGroupPresentModeFlagBitsKHR>;
+
+template <> struct FlagTraits<DeviceGroupPresentModeFlagBitsKHR> {
+  enum : VkFlags {
+    allFlags = VkFlags(DeviceGroupPresentModeFlagBitsKHR::eLocal) |
+               VkFlags(DeviceGroupPresentModeFlagBitsKHR::eRemote) |
+               VkFlags(DeviceGroupPresentModeFlagBitsKHR::eSum) |
+               VkFlags(DeviceGroupPresentModeFlagBitsKHR::eLocalMultiDevice)
+  };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DeviceGroupPresentModeFlagsKHR
+operator|(DeviceGroupPresentModeFlagBitsKHR bit0,
+          DeviceGroupPresentModeFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
+  return DeviceGroupPresentModeFlagsKHR(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DeviceGroupPresentModeFlagsKHR
+operator&(DeviceGroupPresentModeFlagBitsKHR bit0,
+          DeviceGroupPresentModeFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
+  return DeviceGroupPresentModeFlagsKHR(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DeviceGroupPresentModeFlagsKHR
+operator^(DeviceGroupPresentModeFlagBitsKHR bit0,
+          DeviceGroupPresentModeFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
+  return DeviceGroupPresentModeFlagsKHR(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DeviceGroupPresentModeFlagsKHR
+operator~(DeviceGroupPresentModeFlagBitsKHR bits) VULKAN_HPP_NOEXCEPT {
+  return ~(DeviceGroupPresentModeFlagsKHR(bits));
+}
+
+VULKAN_HPP_INLINE std::string to_string(DeviceGroupPresentModeFlagsKHR value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & DeviceGroupPresentModeFlagBitsKHR::eLocal)
+    result += "Local | ";
+  if (value & DeviceGroupPresentModeFlagBitsKHR::eRemote)
+    result += "Remote | ";
+  if (value & DeviceGroupPresentModeFlagBitsKHR::eSum)
+    result += "Sum | ";
+  if (value & DeviceGroupPresentModeFlagBitsKHR::eLocalMultiDevice)
+    result += "LocalMultiDevice | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+//=== VK_KHR_display ===
+
+enum class DisplayModeCreateFlagBitsKHR : VkFlags {};
+
+VULKAN_HPP_INLINE std::string to_string(DisplayModeCreateFlagBitsKHR) {
+  return "(void)";
+}
+
+using DisplayModeCreateFlagsKHR = Flags<DisplayModeCreateFlagBitsKHR>;
+
+VULKAN_HPP_INLINE std::string to_string(DisplayModeCreateFlagsKHR) {
+  return "{}";
+}
+
+using DisplayPlaneAlphaFlagsKHR = Flags<DisplayPlaneAlphaFlagBitsKHR>;
+
+template <> struct FlagTraits<DisplayPlaneAlphaFlagBitsKHR> {
+  enum : VkFlags {
+    allFlags = VkFlags(DisplayPlaneAlphaFlagBitsKHR::eOpaque) |
+               VkFlags(DisplayPlaneAlphaFlagBitsKHR::eGlobal) |
+               VkFlags(DisplayPlaneAlphaFlagBitsKHR::ePerPixel) |
+               VkFlags(DisplayPlaneAlphaFlagBitsKHR::ePerPixelPremultiplied)
+  };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DisplayPlaneAlphaFlagsKHR
+operator|(DisplayPlaneAlphaFlagBitsKHR bit0,
+          DisplayPlaneAlphaFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
+  return DisplayPlaneAlphaFlagsKHR(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DisplayPlaneAlphaFlagsKHR
+operator&(DisplayPlaneAlphaFlagBitsKHR bit0,
+          DisplayPlaneAlphaFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
+  return DisplayPlaneAlphaFlagsKHR(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DisplayPlaneAlphaFlagsKHR
+operator^(DisplayPlaneAlphaFlagBitsKHR bit0,
+          DisplayPlaneAlphaFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
+  return DisplayPlaneAlphaFlagsKHR(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DisplayPlaneAlphaFlagsKHR
+operator~(DisplayPlaneAlphaFlagBitsKHR bits) VULKAN_HPP_NOEXCEPT {
+  return ~(DisplayPlaneAlphaFlagsKHR(bits));
+}
+
+VULKAN_HPP_INLINE std::string to_string(DisplayPlaneAlphaFlagsKHR value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & DisplayPlaneAlphaFlagBitsKHR::eOpaque)
+    result += "Opaque | ";
+  if (value & DisplayPlaneAlphaFlagBitsKHR::eGlobal)
+    result += "Global | ";
+  if (value & DisplayPlaneAlphaFlagBitsKHR::ePerPixel)
+    result += "PerPixel | ";
+  if (value & DisplayPlaneAlphaFlagBitsKHR::ePerPixelPremultiplied)
+    result += "PerPixelPremultiplied | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+enum class DisplaySurfaceCreateFlagBitsKHR : VkFlags {};
+
+VULKAN_HPP_INLINE std::string to_string(DisplaySurfaceCreateFlagBitsKHR) {
+  return "(void)";
+}
+
+using DisplaySurfaceCreateFlagsKHR = Flags<DisplaySurfaceCreateFlagBitsKHR>;
+
+VULKAN_HPP_INLINE std::string to_string(DisplaySurfaceCreateFlagsKHR) {
+  return "{}";
+}
+
+using SurfaceTransformFlagsKHR = Flags<SurfaceTransformFlagBitsKHR>;
+
+template <> struct FlagTraits<SurfaceTransformFlagBitsKHR> {
+  enum : VkFlags {
+    allFlags =
+        VkFlags(SurfaceTransformFlagBitsKHR::eIdentity) |
+        VkFlags(SurfaceTransformFlagBitsKHR::eRotate90) |
+        VkFlags(SurfaceTransformFlagBitsKHR::eRotate180) |
+        VkFlags(SurfaceTransformFlagBitsKHR::eRotate270) |
+        VkFlags(SurfaceTransformFlagBitsKHR::eHorizontalMirror) |
+        VkFlags(SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate90) |
+        VkFlags(SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate180) |
+        VkFlags(SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate270) |
+        VkFlags(SurfaceTransformFlagBitsKHR::eInherit)
+  };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SurfaceTransformFlagsKHR
+operator|(SurfaceTransformFlagBitsKHR bit0,
+          SurfaceTransformFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
+  return SurfaceTransformFlagsKHR(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SurfaceTransformFlagsKHR
+operator&(SurfaceTransformFlagBitsKHR bit0,
+          SurfaceTransformFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
+  return SurfaceTransformFlagsKHR(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SurfaceTransformFlagsKHR
+operator^(SurfaceTransformFlagBitsKHR bit0,
+          SurfaceTransformFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
+  return SurfaceTransformFlagsKHR(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SurfaceTransformFlagsKHR
+operator~(SurfaceTransformFlagBitsKHR bits) VULKAN_HPP_NOEXCEPT {
+  return ~(SurfaceTransformFlagsKHR(bits));
+}
+
+VULKAN_HPP_INLINE std::string to_string(SurfaceTransformFlagsKHR value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & SurfaceTransformFlagBitsKHR::eIdentity)
+    result += "Identity | ";
+  if (value & SurfaceTransformFlagBitsKHR::eRotate90)
+    result += "Rotate90 | ";
+  if (value & SurfaceTransformFlagBitsKHR::eRotate180)
+    result += "Rotate180 | ";
+  if (value & SurfaceTransformFlagBitsKHR::eRotate270)
+    result += "Rotate270 | ";
+  if (value & SurfaceTransformFlagBitsKHR::eHorizontalMirror)
+    result += "HorizontalMirror | ";
+  if (value & SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate90)
+    result += "HorizontalMirrorRotate90 | ";
+  if (value & SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate180)
+    result += "HorizontalMirrorRotate180 | ";
+  if (value & SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate270)
+    result += "HorizontalMirrorRotate270 | ";
+  if (value & SurfaceTransformFlagBitsKHR::eInherit)
+    result += "Inherit | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+#if defined(VK_USE_PLATFORM_XLIB_KHR)
+
+//=== VK_KHR_xlib_surface ===
+
+enum class XlibSurfaceCreateFlagBitsKHR : VkFlags {};
+
+VULKAN_HPP_INLINE std::string to_string(XlibSurfaceCreateFlagBitsKHR) {
+  return "(void)";
+}
+
+using XlibSurfaceCreateFlagsKHR = Flags<XlibSurfaceCreateFlagBitsKHR>;
+
+VULKAN_HPP_INLINE std::string to_string(XlibSurfaceCreateFlagsKHR) {
+  return "{}";
+}
+#endif /*VK_USE_PLATFORM_XLIB_KHR*/
+
+#if defined(VK_USE_PLATFORM_XCB_KHR)
+
+//=== VK_KHR_xcb_surface ===
+
+enum class XcbSurfaceCreateFlagBitsKHR : VkFlags {};
+
+VULKAN_HPP_INLINE std::string to_string(XcbSurfaceCreateFlagBitsKHR) {
+  return "(void)";
+}
+
+using XcbSurfaceCreateFlagsKHR = Flags<XcbSurfaceCreateFlagBitsKHR>;
+
+VULKAN_HPP_INLINE std::string to_string(XcbSurfaceCreateFlagsKHR) {
+  return "{}";
+}
+#endif /*VK_USE_PLATFORM_XCB_KHR*/
+
+#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
+
+//=== VK_KHR_wayland_surface ===
+
+enum class WaylandSurfaceCreateFlagBitsKHR : VkFlags {};
+
+VULKAN_HPP_INLINE std::string to_string(WaylandSurfaceCreateFlagBitsKHR) {
+  return "(void)";
+}
+
+using WaylandSurfaceCreateFlagsKHR = Flags<WaylandSurfaceCreateFlagBitsKHR>;
+
+VULKAN_HPP_INLINE std::string to_string(WaylandSurfaceCreateFlagsKHR) {
+  return "{}";
+}
+#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
+
+#if defined(VK_USE_PLATFORM_ANDROID_KHR)
+
+//=== VK_KHR_android_surface ===
+
+enum class AndroidSurfaceCreateFlagBitsKHR : VkFlags {};
+
+VULKAN_HPP_INLINE std::string to_string(AndroidSurfaceCreateFlagBitsKHR) {
+  return "(void)";
+}
+
+using AndroidSurfaceCreateFlagsKHR = Flags<AndroidSurfaceCreateFlagBitsKHR>;
+
+VULKAN_HPP_INLINE std::string to_string(AndroidSurfaceCreateFlagsKHR) {
+  return "{}";
+}
+#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+
+#if defined(VK_USE_PLATFORM_WIN32_KHR)
+
+//=== VK_KHR_win32_surface ===
+
+enum class Win32SurfaceCreateFlagBitsKHR : VkFlags {};
+
+VULKAN_HPP_INLINE std::string to_string(Win32SurfaceCreateFlagBitsKHR) {
+  return "(void)";
+}
+
+using Win32SurfaceCreateFlagsKHR = Flags<Win32SurfaceCreateFlagBitsKHR>;
+
+VULKAN_HPP_INLINE std::string to_string(Win32SurfaceCreateFlagsKHR) {
+  return "{}";
+}
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+//=== VK_EXT_debug_report ===
+
+using DebugReportFlagsEXT = Flags<DebugReportFlagBitsEXT>;
+
+template <> struct FlagTraits<DebugReportFlagBitsEXT> {
+  enum : VkFlags {
+    allFlags = VkFlags(DebugReportFlagBitsEXT::eInformation) |
+               VkFlags(DebugReportFlagBitsEXT::eWarning) |
+               VkFlags(DebugReportFlagBitsEXT::ePerformanceWarning) |
+               VkFlags(DebugReportFlagBitsEXT::eError) |
+               VkFlags(DebugReportFlagBitsEXT::eDebug)
+  };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DebugReportFlagsEXT
+operator|(DebugReportFlagBitsEXT bit0,
+          DebugReportFlagBitsEXT bit1) VULKAN_HPP_NOEXCEPT {
+  return DebugReportFlagsEXT(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DebugReportFlagsEXT
+operator&(DebugReportFlagBitsEXT bit0,
+          DebugReportFlagBitsEXT bit1) VULKAN_HPP_NOEXCEPT {
+  return DebugReportFlagsEXT(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DebugReportFlagsEXT
+operator^(DebugReportFlagBitsEXT bit0,
+          DebugReportFlagBitsEXT bit1) VULKAN_HPP_NOEXCEPT {
+  return DebugReportFlagsEXT(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DebugReportFlagsEXT
+operator~(DebugReportFlagBitsEXT bits) VULKAN_HPP_NOEXCEPT {
+  return ~(DebugReportFlagsEXT(bits));
+}
+
+VULKAN_HPP_INLINE std::string to_string(DebugReportFlagsEXT value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & DebugReportFlagBitsEXT::eInformation)
+    result += "Information | ";
+  if (value & DebugReportFlagBitsEXT::eWarning)
+    result += "Warning | ";
+  if (value & DebugReportFlagBitsEXT::ePerformanceWarning)
+    result += "PerformanceWarning | ";
+  if (value & DebugReportFlagBitsEXT::eError)
+    result += "Error | ";
+  if (value & DebugReportFlagBitsEXT::eDebug)
+    result += "Debug | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+//=== VK_EXT_transform_feedback ===
+
+enum class PipelineRasterizationStateStreamCreateFlagBitsEXT : VkFlags {};
+
+VULKAN_HPP_INLINE std::string
+to_string(PipelineRasterizationStateStreamCreateFlagBitsEXT) {
+  return "(void)";
+}
+
+using PipelineRasterizationStateStreamCreateFlagsEXT =
+    Flags<PipelineRasterizationStateStreamCreateFlagBitsEXT>;
+
+VULKAN_HPP_INLINE std::string
+to_string(PipelineRasterizationStateStreamCreateFlagsEXT) {
+  return "{}";
+}
+
+#if defined(VK_USE_PLATFORM_GGP)
+
+//=== VK_GGP_stream_descriptor_surface ===
+
+enum class StreamDescriptorSurfaceCreateFlagBitsGGP : VkFlags {};
+
+VULKAN_HPP_INLINE std::string
+to_string(StreamDescriptorSurfaceCreateFlagBitsGGP) {
+  return "(void)";
+}
+
+using StreamDescriptorSurfaceCreateFlagsGGP =
+    Flags<StreamDescriptorSurfaceCreateFlagBitsGGP>;
+
+VULKAN_HPP_INLINE std::string to_string(StreamDescriptorSurfaceCreateFlagsGGP) {
+  return "{}";
+}
+#endif /*VK_USE_PLATFORM_GGP*/
+
+//=== VK_NV_external_memory_capabilities ===
+
+using ExternalMemoryHandleTypeFlagsNV =
+    Flags<ExternalMemoryHandleTypeFlagBitsNV>;
+
+template <> struct FlagTraits<ExternalMemoryHandleTypeFlagBitsNV> {
+  enum : VkFlags {
+    allFlags = VkFlags(ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32) |
+               VkFlags(ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32Kmt) |
+               VkFlags(ExternalMemoryHandleTypeFlagBitsNV::eD3D11Image) |
+               VkFlags(ExternalMemoryHandleTypeFlagBitsNV::eD3D11ImageKmt)
+  };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalMemoryHandleTypeFlagsNV
+operator|(ExternalMemoryHandleTypeFlagBitsNV bit0,
+          ExternalMemoryHandleTypeFlagBitsNV bit1) VULKAN_HPP_NOEXCEPT {
+  return ExternalMemoryHandleTypeFlagsNV(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalMemoryHandleTypeFlagsNV
+operator&(ExternalMemoryHandleTypeFlagBitsNV bit0,
+          ExternalMemoryHandleTypeFlagBitsNV bit1) VULKAN_HPP_NOEXCEPT {
+  return ExternalMemoryHandleTypeFlagsNV(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalMemoryHandleTypeFlagsNV
+operator^(ExternalMemoryHandleTypeFlagBitsNV bit0,
+          ExternalMemoryHandleTypeFlagBitsNV bit1) VULKAN_HPP_NOEXCEPT {
+  return ExternalMemoryHandleTypeFlagsNV(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalMemoryHandleTypeFlagsNV
+operator~(ExternalMemoryHandleTypeFlagBitsNV bits) VULKAN_HPP_NOEXCEPT {
+  return ~(ExternalMemoryHandleTypeFlagsNV(bits));
+}
+
+VULKAN_HPP_INLINE std::string to_string(ExternalMemoryHandleTypeFlagsNV value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32)
+    result += "OpaqueWin32 | ";
+  if (value & ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32Kmt)
+    result += "OpaqueWin32Kmt | ";
+  if (value & ExternalMemoryHandleTypeFlagBitsNV::eD3D11Image)
+    result += "D3D11Image | ";
+  if (value & ExternalMemoryHandleTypeFlagBitsNV::eD3D11ImageKmt)
+    result += "D3D11ImageKmt | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+using ExternalMemoryFeatureFlagsNV = Flags<ExternalMemoryFeatureFlagBitsNV>;
+
+template <> struct FlagTraits<ExternalMemoryFeatureFlagBitsNV> {
+  enum : VkFlags {
+    allFlags = VkFlags(ExternalMemoryFeatureFlagBitsNV::eDedicatedOnly) |
+               VkFlags(ExternalMemoryFeatureFlagBitsNV::eExportable) |
+               VkFlags(ExternalMemoryFeatureFlagBitsNV::eImportable)
+  };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalMemoryFeatureFlagsNV
+operator|(ExternalMemoryFeatureFlagBitsNV bit0,
+          ExternalMemoryFeatureFlagBitsNV bit1) VULKAN_HPP_NOEXCEPT {
+  return ExternalMemoryFeatureFlagsNV(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalMemoryFeatureFlagsNV
+operator&(ExternalMemoryFeatureFlagBitsNV bit0,
+          ExternalMemoryFeatureFlagBitsNV bit1) VULKAN_HPP_NOEXCEPT {
+  return ExternalMemoryFeatureFlagsNV(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalMemoryFeatureFlagsNV
+operator^(ExternalMemoryFeatureFlagBitsNV bit0,
+          ExternalMemoryFeatureFlagBitsNV bit1) VULKAN_HPP_NOEXCEPT {
+  return ExternalMemoryFeatureFlagsNV(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalMemoryFeatureFlagsNV
+operator~(ExternalMemoryFeatureFlagBitsNV bits) VULKAN_HPP_NOEXCEPT {
+  return ~(ExternalMemoryFeatureFlagsNV(bits));
+}
+
+VULKAN_HPP_INLINE std::string to_string(ExternalMemoryFeatureFlagsNV value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & ExternalMemoryFeatureFlagBitsNV::eDedicatedOnly)
+    result += "DedicatedOnly | ";
+  if (value & ExternalMemoryFeatureFlagBitsNV::eExportable)
+    result += "Exportable | ";
+  if (value & ExternalMemoryFeatureFlagBitsNV::eImportable)
+    result += "Importable | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+#if defined(VK_USE_PLATFORM_VI_NN)
+
+//=== VK_NN_vi_surface ===
+
+enum class ViSurfaceCreateFlagBitsNN : VkFlags {};
+
+VULKAN_HPP_INLINE std::string to_string(ViSurfaceCreateFlagBitsNN) {
+  return "(void)";
+}
+
+using ViSurfaceCreateFlagsNN = Flags<ViSurfaceCreateFlagBitsNN>;
+
+VULKAN_HPP_INLINE std::string to_string(ViSurfaceCreateFlagsNN) { return "{}"; }
+#endif /*VK_USE_PLATFORM_VI_NN*/
+
+//=== VK_EXT_conditional_rendering ===
+
+using ConditionalRenderingFlagsEXT = Flags<ConditionalRenderingFlagBitsEXT>;
+
+template <> struct FlagTraits<ConditionalRenderingFlagBitsEXT> {
+  enum : VkFlags {
+    allFlags = VkFlags(ConditionalRenderingFlagBitsEXT::eInverted)
+  };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ConditionalRenderingFlagsEXT
+operator|(ConditionalRenderingFlagBitsEXT bit0,
+          ConditionalRenderingFlagBitsEXT bit1) VULKAN_HPP_NOEXCEPT {
+  return ConditionalRenderingFlagsEXT(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ConditionalRenderingFlagsEXT
+operator&(ConditionalRenderingFlagBitsEXT bit0,
+          ConditionalRenderingFlagBitsEXT bit1) VULKAN_HPP_NOEXCEPT {
+  return ConditionalRenderingFlagsEXT(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ConditionalRenderingFlagsEXT
+operator^(ConditionalRenderingFlagBitsEXT bit0,
+          ConditionalRenderingFlagBitsEXT bit1) VULKAN_HPP_NOEXCEPT {
+  return ConditionalRenderingFlagsEXT(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ConditionalRenderingFlagsEXT
+operator~(ConditionalRenderingFlagBitsEXT bits) VULKAN_HPP_NOEXCEPT {
+  return ~(ConditionalRenderingFlagsEXT(bits));
+}
+
+VULKAN_HPP_INLINE std::string to_string(ConditionalRenderingFlagsEXT value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & ConditionalRenderingFlagBitsEXT::eInverted)
+    result += "Inverted | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+//=== VK_EXT_display_surface_counter ===
+
+using SurfaceCounterFlagsEXT = Flags<SurfaceCounterFlagBitsEXT>;
+
+template <> struct FlagTraits<SurfaceCounterFlagBitsEXT> {
+  enum : VkFlags { allFlags = VkFlags(SurfaceCounterFlagBitsEXT::eVblank) };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SurfaceCounterFlagsEXT
+operator|(SurfaceCounterFlagBitsEXT bit0,
+          SurfaceCounterFlagBitsEXT bit1) VULKAN_HPP_NOEXCEPT {
+  return SurfaceCounterFlagsEXT(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SurfaceCounterFlagsEXT
+operator&(SurfaceCounterFlagBitsEXT bit0,
+          SurfaceCounterFlagBitsEXT bit1) VULKAN_HPP_NOEXCEPT {
+  return SurfaceCounterFlagsEXT(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SurfaceCounterFlagsEXT
+operator^(SurfaceCounterFlagBitsEXT bit0,
+          SurfaceCounterFlagBitsEXT bit1) VULKAN_HPP_NOEXCEPT {
+  return SurfaceCounterFlagsEXT(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SurfaceCounterFlagsEXT
+operator~(SurfaceCounterFlagBitsEXT bits) VULKAN_HPP_NOEXCEPT {
+  return ~(SurfaceCounterFlagsEXT(bits));
+}
+
+VULKAN_HPP_INLINE std::string to_string(SurfaceCounterFlagsEXT value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & SurfaceCounterFlagBitsEXT::eVblank)
+    result += "Vblank | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+//=== VK_NV_viewport_swizzle ===
+
+enum class PipelineViewportSwizzleStateCreateFlagBitsNV : VkFlags {};
+
+VULKAN_HPP_INLINE std::string
+to_string(PipelineViewportSwizzleStateCreateFlagBitsNV) {
+  return "(void)";
+}
+
+using PipelineViewportSwizzleStateCreateFlagsNV =
+    Flags<PipelineViewportSwizzleStateCreateFlagBitsNV>;
+
+VULKAN_HPP_INLINE std::string
+to_string(PipelineViewportSwizzleStateCreateFlagsNV) {
+  return "{}";
+}
+
+//=== VK_EXT_discard_rectangles ===
+
+enum class PipelineDiscardRectangleStateCreateFlagBitsEXT : VkFlags {};
+
+VULKAN_HPP_INLINE std::string
+to_string(PipelineDiscardRectangleStateCreateFlagBitsEXT) {
+  return "(void)";
+}
+
+using PipelineDiscardRectangleStateCreateFlagsEXT =
+    Flags<PipelineDiscardRectangleStateCreateFlagBitsEXT>;
+
+VULKAN_HPP_INLINE std::string
+to_string(PipelineDiscardRectangleStateCreateFlagsEXT) {
+  return "{}";
+}
+
+//=== VK_EXT_conservative_rasterization ===
+
+enum class PipelineRasterizationConservativeStateCreateFlagBitsEXT : VkFlags {};
+
+VULKAN_HPP_INLINE std::string
+to_string(PipelineRasterizationConservativeStateCreateFlagBitsEXT) {
+  return "(void)";
+}
+
+using PipelineRasterizationConservativeStateCreateFlagsEXT =
+    Flags<PipelineRasterizationConservativeStateCreateFlagBitsEXT>;
+
+VULKAN_HPP_INLINE std::string
+to_string(PipelineRasterizationConservativeStateCreateFlagsEXT) {
+  return "{}";
+}
+
+//=== VK_EXT_depth_clip_enable ===
+
+enum class PipelineRasterizationDepthClipStateCreateFlagBitsEXT : VkFlags {};
+
+VULKAN_HPP_INLINE std::string
+to_string(PipelineRasterizationDepthClipStateCreateFlagBitsEXT) {
+  return "(void)";
+}
+
+using PipelineRasterizationDepthClipStateCreateFlagsEXT =
+    Flags<PipelineRasterizationDepthClipStateCreateFlagBitsEXT>;
+
+VULKAN_HPP_INLINE std::string
+to_string(PipelineRasterizationDepthClipStateCreateFlagsEXT) {
+  return "{}";
+}
+
+//=== VK_KHR_performance_query ===
+
+using PerformanceCounterDescriptionFlagsKHR =
+    Flags<PerformanceCounterDescriptionFlagBitsKHR>;
+
+template <> struct FlagTraits<PerformanceCounterDescriptionFlagBitsKHR> {
+  enum : VkFlags {
+    allFlags =
+        VkFlags(
+            PerformanceCounterDescriptionFlagBitsKHR::ePerformanceImpacting) |
+        VkFlags(PerformanceCounterDescriptionFlagBitsKHR::eConcurrentlyImpacted)
+  };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PerformanceCounterDescriptionFlagsKHR
+operator|(PerformanceCounterDescriptionFlagBitsKHR bit0,
+          PerformanceCounterDescriptionFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
+  return PerformanceCounterDescriptionFlagsKHR(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PerformanceCounterDescriptionFlagsKHR
+operator&(PerformanceCounterDescriptionFlagBitsKHR bit0,
+          PerformanceCounterDescriptionFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
+  return PerformanceCounterDescriptionFlagsKHR(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PerformanceCounterDescriptionFlagsKHR
+operator^(PerformanceCounterDescriptionFlagBitsKHR bit0,
+          PerformanceCounterDescriptionFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
+  return PerformanceCounterDescriptionFlagsKHR(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PerformanceCounterDescriptionFlagsKHR
+operator~(PerformanceCounterDescriptionFlagBitsKHR bits) VULKAN_HPP_NOEXCEPT {
+  return ~(PerformanceCounterDescriptionFlagsKHR(bits));
+}
+
+VULKAN_HPP_INLINE std::string
+to_string(PerformanceCounterDescriptionFlagsKHR value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & PerformanceCounterDescriptionFlagBitsKHR::ePerformanceImpacting)
+    result += "PerformanceImpacting | ";
+  if (value & PerformanceCounterDescriptionFlagBitsKHR::eConcurrentlyImpacted)
+    result += "ConcurrentlyImpacted | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+using AcquireProfilingLockFlagsKHR = Flags<AcquireProfilingLockFlagBitsKHR>;
+
+VULKAN_HPP_INLINE std::string to_string(AcquireProfilingLockFlagsKHR) {
+  return "{}";
+}
+
+#if defined(VK_USE_PLATFORM_IOS_MVK)
+
+//=== VK_MVK_ios_surface ===
+
+enum class IOSSurfaceCreateFlagBitsMVK : VkFlags {};
+
+VULKAN_HPP_INLINE std::string to_string(IOSSurfaceCreateFlagBitsMVK) {
+  return "(void)";
+}
+
+using IOSSurfaceCreateFlagsMVK = Flags<IOSSurfaceCreateFlagBitsMVK>;
+
+VULKAN_HPP_INLINE std::string to_string(IOSSurfaceCreateFlagsMVK) {
+  return "{}";
+}
+#endif /*VK_USE_PLATFORM_IOS_MVK*/
+
+#if defined(VK_USE_PLATFORM_MACOS_MVK)
+
+//=== VK_MVK_macos_surface ===
+
+enum class MacOSSurfaceCreateFlagBitsMVK : VkFlags {};
+
+VULKAN_HPP_INLINE std::string to_string(MacOSSurfaceCreateFlagBitsMVK) {
+  return "(void)";
+}
+
+using MacOSSurfaceCreateFlagsMVK = Flags<MacOSSurfaceCreateFlagBitsMVK>;
+
+VULKAN_HPP_INLINE std::string to_string(MacOSSurfaceCreateFlagsMVK) {
+  return "{}";
+}
+#endif /*VK_USE_PLATFORM_MACOS_MVK*/
+
+//=== VK_EXT_debug_utils ===
+
+using DebugUtilsMessageSeverityFlagsEXT =
+    Flags<DebugUtilsMessageSeverityFlagBitsEXT>;
+
+template <> struct FlagTraits<DebugUtilsMessageSeverityFlagBitsEXT> {
+  enum : VkFlags {
+    allFlags = VkFlags(DebugUtilsMessageSeverityFlagBitsEXT::eVerbose) |
+               VkFlags(DebugUtilsMessageSeverityFlagBitsEXT::eInfo) |
+               VkFlags(DebugUtilsMessageSeverityFlagBitsEXT::eWarning) |
+               VkFlags(DebugUtilsMessageSeverityFlagBitsEXT::eError)
+  };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DebugUtilsMessageSeverityFlagsEXT
+operator|(DebugUtilsMessageSeverityFlagBitsEXT bit0,
+          DebugUtilsMessageSeverityFlagBitsEXT bit1) VULKAN_HPP_NOEXCEPT {
+  return DebugUtilsMessageSeverityFlagsEXT(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DebugUtilsMessageSeverityFlagsEXT
+operator&(DebugUtilsMessageSeverityFlagBitsEXT bit0,
+          DebugUtilsMessageSeverityFlagBitsEXT bit1) VULKAN_HPP_NOEXCEPT {
+  return DebugUtilsMessageSeverityFlagsEXT(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DebugUtilsMessageSeverityFlagsEXT
+operator^(DebugUtilsMessageSeverityFlagBitsEXT bit0,
+          DebugUtilsMessageSeverityFlagBitsEXT bit1) VULKAN_HPP_NOEXCEPT {
+  return DebugUtilsMessageSeverityFlagsEXT(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DebugUtilsMessageSeverityFlagsEXT
+operator~(DebugUtilsMessageSeverityFlagBitsEXT bits) VULKAN_HPP_NOEXCEPT {
+  return ~(DebugUtilsMessageSeverityFlagsEXT(bits));
+}
+
+VULKAN_HPP_INLINE std::string
+to_string(DebugUtilsMessageSeverityFlagsEXT value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & DebugUtilsMessageSeverityFlagBitsEXT::eVerbose)
+    result += "Verbose | ";
+  if (value & DebugUtilsMessageSeverityFlagBitsEXT::eInfo)
+    result += "Info | ";
+  if (value & DebugUtilsMessageSeverityFlagBitsEXT::eWarning)
+    result += "Warning | ";
+  if (value & DebugUtilsMessageSeverityFlagBitsEXT::eError)
+    result += "Error | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+using DebugUtilsMessageTypeFlagsEXT = Flags<DebugUtilsMessageTypeFlagBitsEXT>;
+
+template <> struct FlagTraits<DebugUtilsMessageTypeFlagBitsEXT> {
+  enum : VkFlags {
+    allFlags = VkFlags(DebugUtilsMessageTypeFlagBitsEXT::eGeneral) |
+               VkFlags(DebugUtilsMessageTypeFlagBitsEXT::eValidation) |
+               VkFlags(DebugUtilsMessageTypeFlagBitsEXT::ePerformance)
+  };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DebugUtilsMessageTypeFlagsEXT
+operator|(DebugUtilsMessageTypeFlagBitsEXT bit0,
+          DebugUtilsMessageTypeFlagBitsEXT bit1) VULKAN_HPP_NOEXCEPT {
+  return DebugUtilsMessageTypeFlagsEXT(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DebugUtilsMessageTypeFlagsEXT
+operator&(DebugUtilsMessageTypeFlagBitsEXT bit0,
+          DebugUtilsMessageTypeFlagBitsEXT bit1) VULKAN_HPP_NOEXCEPT {
+  return DebugUtilsMessageTypeFlagsEXT(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DebugUtilsMessageTypeFlagsEXT
+operator^(DebugUtilsMessageTypeFlagBitsEXT bit0,
+          DebugUtilsMessageTypeFlagBitsEXT bit1) VULKAN_HPP_NOEXCEPT {
+  return DebugUtilsMessageTypeFlagsEXT(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DebugUtilsMessageTypeFlagsEXT
+operator~(DebugUtilsMessageTypeFlagBitsEXT bits) VULKAN_HPP_NOEXCEPT {
+  return ~(DebugUtilsMessageTypeFlagsEXT(bits));
+}
+
+VULKAN_HPP_INLINE std::string to_string(DebugUtilsMessageTypeFlagsEXT value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & DebugUtilsMessageTypeFlagBitsEXT::eGeneral)
+    result += "General | ";
+  if (value & DebugUtilsMessageTypeFlagBitsEXT::eValidation)
+    result += "Validation | ";
+  if (value & DebugUtilsMessageTypeFlagBitsEXT::ePerformance)
+    result += "Performance | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+enum class DebugUtilsMessengerCallbackDataFlagBitsEXT : VkFlags {};
+
+VULKAN_HPP_INLINE std::string
+to_string(DebugUtilsMessengerCallbackDataFlagBitsEXT) {
+  return "(void)";
+}
+
+using DebugUtilsMessengerCallbackDataFlagsEXT =
+    Flags<DebugUtilsMessengerCallbackDataFlagBitsEXT>;
+
+VULKAN_HPP_INLINE std::string
+to_string(DebugUtilsMessengerCallbackDataFlagsEXT) {
+  return "{}";
+}
+
+enum class DebugUtilsMessengerCreateFlagBitsEXT : VkFlags {};
+
+VULKAN_HPP_INLINE std::string to_string(DebugUtilsMessengerCreateFlagBitsEXT) {
+  return "(void)";
+}
+
+using DebugUtilsMessengerCreateFlagsEXT =
+    Flags<DebugUtilsMessengerCreateFlagBitsEXT>;
+
+VULKAN_HPP_INLINE std::string to_string(DebugUtilsMessengerCreateFlagsEXT) {
+  return "{}";
+}
+
+//=== VK_NV_fragment_coverage_to_color ===
+
+enum class PipelineCoverageToColorStateCreateFlagBitsNV : VkFlags {};
+
+VULKAN_HPP_INLINE std::string
+to_string(PipelineCoverageToColorStateCreateFlagBitsNV) {
+  return "(void)";
+}
+
+using PipelineCoverageToColorStateCreateFlagsNV =
+    Flags<PipelineCoverageToColorStateCreateFlagBitsNV>;
+
+VULKAN_HPP_INLINE std::string
+to_string(PipelineCoverageToColorStateCreateFlagsNV) {
+  return "{}";
+}
+
+//=== VK_KHR_acceleration_structure ===
+
+using GeometryFlagsKHR = Flags<GeometryFlagBitsKHR>;
+
+template <> struct FlagTraits<GeometryFlagBitsKHR> {
+  enum : VkFlags {
+    allFlags = VkFlags(GeometryFlagBitsKHR::eOpaque) |
+               VkFlags(GeometryFlagBitsKHR::eNoDuplicateAnyHitInvocation)
+  };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR GeometryFlagsKHR operator|(
+    GeometryFlagBitsKHR bit0, GeometryFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
+  return GeometryFlagsKHR(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR GeometryFlagsKHR operator&(
+    GeometryFlagBitsKHR bit0, GeometryFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
+  return GeometryFlagsKHR(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR GeometryFlagsKHR operator^(
+    GeometryFlagBitsKHR bit0, GeometryFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
+  return GeometryFlagsKHR(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR GeometryFlagsKHR
+operator~(GeometryFlagBitsKHR bits) VULKAN_HPP_NOEXCEPT {
+  return ~(GeometryFlagsKHR(bits));
+}
+
+using GeometryFlagsNV = GeometryFlagsKHR;
+
+VULKAN_HPP_INLINE std::string to_string(GeometryFlagsKHR value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & GeometryFlagBitsKHR::eOpaque)
+    result += "Opaque | ";
+  if (value & GeometryFlagBitsKHR::eNoDuplicateAnyHitInvocation)
+    result += "NoDuplicateAnyHitInvocation | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+using GeometryInstanceFlagsKHR = Flags<GeometryInstanceFlagBitsKHR>;
+
+template <> struct FlagTraits<GeometryInstanceFlagBitsKHR> {
+  enum : VkFlags {
+    allFlags =
+        VkFlags(GeometryInstanceFlagBitsKHR::eTriangleFacingCullDisable) |
+        VkFlags(GeometryInstanceFlagBitsKHR::eTriangleFrontCounterclockwise) |
+        VkFlags(GeometryInstanceFlagBitsKHR::eForceOpaque) |
+        VkFlags(GeometryInstanceFlagBitsKHR::eForceNoOpaque)
+  };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR GeometryInstanceFlagsKHR
+operator|(GeometryInstanceFlagBitsKHR bit0,
+          GeometryInstanceFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
+  return GeometryInstanceFlagsKHR(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR GeometryInstanceFlagsKHR
+operator&(GeometryInstanceFlagBitsKHR bit0,
+          GeometryInstanceFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
+  return GeometryInstanceFlagsKHR(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR GeometryInstanceFlagsKHR
+operator^(GeometryInstanceFlagBitsKHR bit0,
+          GeometryInstanceFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
+  return GeometryInstanceFlagsKHR(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR GeometryInstanceFlagsKHR
+operator~(GeometryInstanceFlagBitsKHR bits) VULKAN_HPP_NOEXCEPT {
+  return ~(GeometryInstanceFlagsKHR(bits));
+}
+
+using GeometryInstanceFlagsNV = GeometryInstanceFlagsKHR;
+
+VULKAN_HPP_INLINE std::string to_string(GeometryInstanceFlagsKHR value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & GeometryInstanceFlagBitsKHR::eTriangleFacingCullDisable)
+    result += "TriangleFacingCullDisable | ";
+  if (value & GeometryInstanceFlagBitsKHR::eTriangleFrontCounterclockwise)
+    result += "TriangleFrontCounterclockwise | ";
+  if (value & GeometryInstanceFlagBitsKHR::eForceOpaque)
+    result += "ForceOpaque | ";
+  if (value & GeometryInstanceFlagBitsKHR::eForceNoOpaque)
+    result += "ForceNoOpaque | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+using BuildAccelerationStructureFlagsKHR =
+    Flags<BuildAccelerationStructureFlagBitsKHR>;
+
+template <> struct FlagTraits<BuildAccelerationStructureFlagBitsKHR> {
+  enum : VkFlags {
+    allFlags =
+        VkFlags(BuildAccelerationStructureFlagBitsKHR::eAllowUpdate) |
+        VkFlags(BuildAccelerationStructureFlagBitsKHR::eAllowCompaction) |
+        VkFlags(BuildAccelerationStructureFlagBitsKHR::ePreferFastTrace) |
+        VkFlags(BuildAccelerationStructureFlagBitsKHR::ePreferFastBuild) |
+        VkFlags(BuildAccelerationStructureFlagBitsKHR::eLowMemory)
+  };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR BuildAccelerationStructureFlagsKHR
+operator|(BuildAccelerationStructureFlagBitsKHR bit0,
+          BuildAccelerationStructureFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
+  return BuildAccelerationStructureFlagsKHR(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR BuildAccelerationStructureFlagsKHR
+operator&(BuildAccelerationStructureFlagBitsKHR bit0,
+          BuildAccelerationStructureFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
+  return BuildAccelerationStructureFlagsKHR(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR BuildAccelerationStructureFlagsKHR
+operator^(BuildAccelerationStructureFlagBitsKHR bit0,
+          BuildAccelerationStructureFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
+  return BuildAccelerationStructureFlagsKHR(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR BuildAccelerationStructureFlagsKHR
+operator~(BuildAccelerationStructureFlagBitsKHR bits) VULKAN_HPP_NOEXCEPT {
+  return ~(BuildAccelerationStructureFlagsKHR(bits));
+}
+
+using BuildAccelerationStructureFlagsNV = BuildAccelerationStructureFlagsKHR;
+
+VULKAN_HPP_INLINE std::string
+to_string(BuildAccelerationStructureFlagsKHR value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & BuildAccelerationStructureFlagBitsKHR::eAllowUpdate)
+    result += "AllowUpdate | ";
+  if (value & BuildAccelerationStructureFlagBitsKHR::eAllowCompaction)
+    result += "AllowCompaction | ";
+  if (value & BuildAccelerationStructureFlagBitsKHR::ePreferFastTrace)
+    result += "PreferFastTrace | ";
+  if (value & BuildAccelerationStructureFlagBitsKHR::ePreferFastBuild)
+    result += "PreferFastBuild | ";
+  if (value & BuildAccelerationStructureFlagBitsKHR::eLowMemory)
+    result += "LowMemory | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+using AccelerationStructureCreateFlagsKHR =
+    Flags<AccelerationStructureCreateFlagBitsKHR>;
+
+template <> struct FlagTraits<AccelerationStructureCreateFlagBitsKHR> {
+  enum : VkFlags {
+    allFlags = VkFlags(
+        AccelerationStructureCreateFlagBitsKHR::eDeviceAddressCaptureReplay)
+  };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR AccelerationStructureCreateFlagsKHR
+operator|(AccelerationStructureCreateFlagBitsKHR bit0,
+          AccelerationStructureCreateFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
+  return AccelerationStructureCreateFlagsKHR(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR AccelerationStructureCreateFlagsKHR
+operator&(AccelerationStructureCreateFlagBitsKHR bit0,
+          AccelerationStructureCreateFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
+  return AccelerationStructureCreateFlagsKHR(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR AccelerationStructureCreateFlagsKHR
+operator^(AccelerationStructureCreateFlagBitsKHR bit0,
+          AccelerationStructureCreateFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
+  return AccelerationStructureCreateFlagsKHR(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR AccelerationStructureCreateFlagsKHR
+operator~(AccelerationStructureCreateFlagBitsKHR bits) VULKAN_HPP_NOEXCEPT {
+  return ~(AccelerationStructureCreateFlagsKHR(bits));
+}
+
+VULKAN_HPP_INLINE std::string
+to_string(AccelerationStructureCreateFlagsKHR value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value &
+      AccelerationStructureCreateFlagBitsKHR::eDeviceAddressCaptureReplay)
+    result += "DeviceAddressCaptureReplay | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+//=== VK_NV_framebuffer_mixed_samples ===
+
+enum class PipelineCoverageModulationStateCreateFlagBitsNV : VkFlags {};
+
+VULKAN_HPP_INLINE std::string
+to_string(PipelineCoverageModulationStateCreateFlagBitsNV) {
+  return "(void)";
+}
+
+using PipelineCoverageModulationStateCreateFlagsNV =
+    Flags<PipelineCoverageModulationStateCreateFlagBitsNV>;
+
+VULKAN_HPP_INLINE std::string
+to_string(PipelineCoverageModulationStateCreateFlagsNV) {
+  return "{}";
+}
+
+//=== VK_EXT_validation_cache ===
+
+enum class ValidationCacheCreateFlagBitsEXT : VkFlags {};
+
+VULKAN_HPP_INLINE std::string to_string(ValidationCacheCreateFlagBitsEXT) {
+  return "(void)";
+}
+
+using ValidationCacheCreateFlagsEXT = Flags<ValidationCacheCreateFlagBitsEXT>;
+
+VULKAN_HPP_INLINE std::string to_string(ValidationCacheCreateFlagsEXT) {
+  return "{}";
+}
+
+//=== VK_AMD_pipeline_compiler_control ===
+
+using PipelineCompilerControlFlagsAMD =
+    Flags<PipelineCompilerControlFlagBitsAMD>;
+
+VULKAN_HPP_INLINE std::string to_string(PipelineCompilerControlFlagsAMD) {
+  return "{}";
+}
+
+//=== VK_EXT_pipeline_creation_feedback ===
+
+using PipelineCreationFeedbackFlagsEXT =
+    Flags<PipelineCreationFeedbackFlagBitsEXT>;
+
+template <> struct FlagTraits<PipelineCreationFeedbackFlagBitsEXT> {
+  enum : VkFlags {
+    allFlags =
+        VkFlags(PipelineCreationFeedbackFlagBitsEXT::eValid) |
+        VkFlags(
+            PipelineCreationFeedbackFlagBitsEXT::eApplicationPipelineCacheHit) |
+        VkFlags(PipelineCreationFeedbackFlagBitsEXT::eBasePipelineAcceleration)
+  };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PipelineCreationFeedbackFlagsEXT
+operator|(PipelineCreationFeedbackFlagBitsEXT bit0,
+          PipelineCreationFeedbackFlagBitsEXT bit1) VULKAN_HPP_NOEXCEPT {
+  return PipelineCreationFeedbackFlagsEXT(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PipelineCreationFeedbackFlagsEXT
+operator&(PipelineCreationFeedbackFlagBitsEXT bit0,
+          PipelineCreationFeedbackFlagBitsEXT bit1) VULKAN_HPP_NOEXCEPT {
+  return PipelineCreationFeedbackFlagsEXT(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PipelineCreationFeedbackFlagsEXT
+operator^(PipelineCreationFeedbackFlagBitsEXT bit0,
+          PipelineCreationFeedbackFlagBitsEXT bit1) VULKAN_HPP_NOEXCEPT {
+  return PipelineCreationFeedbackFlagsEXT(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PipelineCreationFeedbackFlagsEXT
+operator~(PipelineCreationFeedbackFlagBitsEXT bits) VULKAN_HPP_NOEXCEPT {
+  return ~(PipelineCreationFeedbackFlagsEXT(bits));
+}
+
+VULKAN_HPP_INLINE std::string
+to_string(PipelineCreationFeedbackFlagsEXT value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & PipelineCreationFeedbackFlagBitsEXT::eValid)
+    result += "Valid | ";
+  if (value & PipelineCreationFeedbackFlagBitsEXT::eApplicationPipelineCacheHit)
+    result += "ApplicationPipelineCacheHit | ";
+  if (value & PipelineCreationFeedbackFlagBitsEXT::eBasePipelineAcceleration)
+    result += "BasePipelineAcceleration | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+
+//=== VK_FUCHSIA_imagepipe_surface ===
+
+enum class ImagePipeSurfaceCreateFlagBitsFUCHSIA : VkFlags {};
+
+VULKAN_HPP_INLINE std::string to_string(ImagePipeSurfaceCreateFlagBitsFUCHSIA) {
+  return "(void)";
+}
+
+using ImagePipeSurfaceCreateFlagsFUCHSIA =
+    Flags<ImagePipeSurfaceCreateFlagBitsFUCHSIA>;
+
+VULKAN_HPP_INLINE std::string to_string(ImagePipeSurfaceCreateFlagsFUCHSIA) {
+  return "{}";
+}
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+
+#if defined(VK_USE_PLATFORM_METAL_EXT)
+
+//=== VK_EXT_metal_surface ===
+
+enum class MetalSurfaceCreateFlagBitsEXT : VkFlags {};
+
+VULKAN_HPP_INLINE std::string to_string(MetalSurfaceCreateFlagBitsEXT) {
+  return "(void)";
+}
+
+using MetalSurfaceCreateFlagsEXT = Flags<MetalSurfaceCreateFlagBitsEXT>;
+
+VULKAN_HPP_INLINE std::string to_string(MetalSurfaceCreateFlagsEXT) {
+  return "{}";
+}
+#endif /*VK_USE_PLATFORM_METAL_EXT*/
+
+//=== VK_AMD_shader_core_properties2 ===
+
+using ShaderCorePropertiesFlagsAMD = Flags<ShaderCorePropertiesFlagBitsAMD>;
+
+VULKAN_HPP_INLINE std::string to_string(ShaderCorePropertiesFlagsAMD) {
+  return "{}";
+}
+
+//=== VK_EXT_tooling_info ===
+
+using ToolPurposeFlagsEXT = Flags<ToolPurposeFlagBitsEXT>;
+
+template <> struct FlagTraits<ToolPurposeFlagBitsEXT> {
+  enum : VkFlags {
+    allFlags = VkFlags(ToolPurposeFlagBitsEXT::eValidation) |
+               VkFlags(ToolPurposeFlagBitsEXT::eProfiling) |
+               VkFlags(ToolPurposeFlagBitsEXT::eTracing) |
+               VkFlags(ToolPurposeFlagBitsEXT::eAdditionalFeatures) |
+               VkFlags(ToolPurposeFlagBitsEXT::eModifyingFeatures) |
+               VkFlags(ToolPurposeFlagBitsEXT::eDebugReporting) |
+               VkFlags(ToolPurposeFlagBitsEXT::eDebugMarkers)
+  };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ToolPurposeFlagsEXT
+operator|(ToolPurposeFlagBitsEXT bit0,
+          ToolPurposeFlagBitsEXT bit1) VULKAN_HPP_NOEXCEPT {
+  return ToolPurposeFlagsEXT(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ToolPurposeFlagsEXT
+operator&(ToolPurposeFlagBitsEXT bit0,
+          ToolPurposeFlagBitsEXT bit1) VULKAN_HPP_NOEXCEPT {
+  return ToolPurposeFlagsEXT(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ToolPurposeFlagsEXT
+operator^(ToolPurposeFlagBitsEXT bit0,
+          ToolPurposeFlagBitsEXT bit1) VULKAN_HPP_NOEXCEPT {
+  return ToolPurposeFlagsEXT(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ToolPurposeFlagsEXT
+operator~(ToolPurposeFlagBitsEXT bits) VULKAN_HPP_NOEXCEPT {
+  return ~(ToolPurposeFlagsEXT(bits));
+}
+
+VULKAN_HPP_INLINE std::string to_string(ToolPurposeFlagsEXT value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & ToolPurposeFlagBitsEXT::eValidation)
+    result += "Validation | ";
+  if (value & ToolPurposeFlagBitsEXT::eProfiling)
+    result += "Profiling | ";
+  if (value & ToolPurposeFlagBitsEXT::eTracing)
+    result += "Tracing | ";
+  if (value & ToolPurposeFlagBitsEXT::eAdditionalFeatures)
+    result += "AdditionalFeatures | ";
+  if (value & ToolPurposeFlagBitsEXT::eModifyingFeatures)
+    result += "ModifyingFeatures | ";
+  if (value & ToolPurposeFlagBitsEXT::eDebugReporting)
+    result += "DebugReporting | ";
+  if (value & ToolPurposeFlagBitsEXT::eDebugMarkers)
+    result += "DebugMarkers | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+//=== VK_NV_coverage_reduction_mode ===
+
+enum class PipelineCoverageReductionStateCreateFlagBitsNV : VkFlags {};
+
+VULKAN_HPP_INLINE std::string
+to_string(PipelineCoverageReductionStateCreateFlagBitsNV) {
+  return "(void)";
+}
+
+using PipelineCoverageReductionStateCreateFlagsNV =
+    Flags<PipelineCoverageReductionStateCreateFlagBitsNV>;
+
+VULKAN_HPP_INLINE std::string
+to_string(PipelineCoverageReductionStateCreateFlagsNV) {
+  return "{}";
+}
+
+//=== VK_EXT_headless_surface ===
+
+enum class HeadlessSurfaceCreateFlagBitsEXT : VkFlags {};
+
+VULKAN_HPP_INLINE std::string to_string(HeadlessSurfaceCreateFlagBitsEXT) {
+  return "(void)";
+}
+
+using HeadlessSurfaceCreateFlagsEXT = Flags<HeadlessSurfaceCreateFlagBitsEXT>;
+
+VULKAN_HPP_INLINE std::string to_string(HeadlessSurfaceCreateFlagsEXT) {
+  return "{}";
+}
+
+//=== VK_NV_device_generated_commands ===
+
+using IndirectStateFlagsNV = Flags<IndirectStateFlagBitsNV>;
+
+template <> struct FlagTraits<IndirectStateFlagBitsNV> {
+  enum : VkFlags {
+    allFlags = VkFlags(IndirectStateFlagBitsNV::eFlagFrontface)
+  };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR IndirectStateFlagsNV
+operator|(IndirectStateFlagBitsNV bit0,
+          IndirectStateFlagBitsNV bit1) VULKAN_HPP_NOEXCEPT {
+  return IndirectStateFlagsNV(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR IndirectStateFlagsNV
+operator&(IndirectStateFlagBitsNV bit0,
+          IndirectStateFlagBitsNV bit1) VULKAN_HPP_NOEXCEPT {
+  return IndirectStateFlagsNV(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR IndirectStateFlagsNV
+operator^(IndirectStateFlagBitsNV bit0,
+          IndirectStateFlagBitsNV bit1) VULKAN_HPP_NOEXCEPT {
+  return IndirectStateFlagsNV(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR IndirectStateFlagsNV
+operator~(IndirectStateFlagBitsNV bits) VULKAN_HPP_NOEXCEPT {
+  return ~(IndirectStateFlagsNV(bits));
+}
+
+VULKAN_HPP_INLINE std::string to_string(IndirectStateFlagsNV value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & IndirectStateFlagBitsNV::eFlagFrontface)
+    result += "FlagFrontface | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+using IndirectCommandsLayoutUsageFlagsNV =
+    Flags<IndirectCommandsLayoutUsageFlagBitsNV>;
+
+template <> struct FlagTraits<IndirectCommandsLayoutUsageFlagBitsNV> {
+  enum : VkFlags {
+    allFlags =
+        VkFlags(IndirectCommandsLayoutUsageFlagBitsNV::eExplicitPreprocess) |
+        VkFlags(IndirectCommandsLayoutUsageFlagBitsNV::eIndexedSequences) |
+        VkFlags(IndirectCommandsLayoutUsageFlagBitsNV::eUnorderedSequences)
+  };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutUsageFlagsNV
+operator|(IndirectCommandsLayoutUsageFlagBitsNV bit0,
+          IndirectCommandsLayoutUsageFlagBitsNV bit1) VULKAN_HPP_NOEXCEPT {
+  return IndirectCommandsLayoutUsageFlagsNV(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutUsageFlagsNV
+operator&(IndirectCommandsLayoutUsageFlagBitsNV bit0,
+          IndirectCommandsLayoutUsageFlagBitsNV bit1) VULKAN_HPP_NOEXCEPT {
+  return IndirectCommandsLayoutUsageFlagsNV(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutUsageFlagsNV
+operator^(IndirectCommandsLayoutUsageFlagBitsNV bit0,
+          IndirectCommandsLayoutUsageFlagBitsNV bit1) VULKAN_HPP_NOEXCEPT {
+  return IndirectCommandsLayoutUsageFlagsNV(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutUsageFlagsNV
+operator~(IndirectCommandsLayoutUsageFlagBitsNV bits) VULKAN_HPP_NOEXCEPT {
+  return ~(IndirectCommandsLayoutUsageFlagsNV(bits));
+}
+
+VULKAN_HPP_INLINE std::string
+to_string(IndirectCommandsLayoutUsageFlagsNV value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & IndirectCommandsLayoutUsageFlagBitsNV::eExplicitPreprocess)
+    result += "ExplicitPreprocess | ";
+  if (value & IndirectCommandsLayoutUsageFlagBitsNV::eIndexedSequences)
+    result += "IndexedSequences | ";
+  if (value & IndirectCommandsLayoutUsageFlagBitsNV::eUnorderedSequences)
+    result += "UnorderedSequences | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+//=== VK_EXT_device_memory_report ===
+
+enum class DeviceMemoryReportFlagBitsEXT : VkFlags {};
+
+VULKAN_HPP_INLINE std::string to_string(DeviceMemoryReportFlagBitsEXT) {
+  return "(void)";
+}
+
+using DeviceMemoryReportFlagsEXT = Flags<DeviceMemoryReportFlagBitsEXT>;
+
+VULKAN_HPP_INLINE std::string to_string(DeviceMemoryReportFlagsEXT) {
+  return "{}";
+}
+
+//=== VK_EXT_private_data ===
+
+using PrivateDataSlotCreateFlagsEXT = Flags<PrivateDataSlotCreateFlagBitsEXT>;
+
+VULKAN_HPP_INLINE std::string to_string(PrivateDataSlotCreateFlagsEXT) {
+  return "{}";
+}
+
+//=== VK_NV_device_diagnostics_config ===
+
+using DeviceDiagnosticsConfigFlagsNV = Flags<DeviceDiagnosticsConfigFlagBitsNV>;
+
+template <> struct FlagTraits<DeviceDiagnosticsConfigFlagBitsNV> {
+  enum : VkFlags {
+    allFlags =
+        VkFlags(DeviceDiagnosticsConfigFlagBitsNV::eEnableShaderDebugInfo) |
+        VkFlags(DeviceDiagnosticsConfigFlagBitsNV::eEnableResourceTracking) |
+        VkFlags(DeviceDiagnosticsConfigFlagBitsNV::eEnableAutomaticCheckpoints)
+  };
+};
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DeviceDiagnosticsConfigFlagsNV
+operator|(DeviceDiagnosticsConfigFlagBitsNV bit0,
+          DeviceDiagnosticsConfigFlagBitsNV bit1) VULKAN_HPP_NOEXCEPT {
+  return DeviceDiagnosticsConfigFlagsNV(bit0) | bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DeviceDiagnosticsConfigFlagsNV
+operator&(DeviceDiagnosticsConfigFlagBitsNV bit0,
+          DeviceDiagnosticsConfigFlagBitsNV bit1) VULKAN_HPP_NOEXCEPT {
+  return DeviceDiagnosticsConfigFlagsNV(bit0) & bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DeviceDiagnosticsConfigFlagsNV
+operator^(DeviceDiagnosticsConfigFlagBitsNV bit0,
+          DeviceDiagnosticsConfigFlagBitsNV bit1) VULKAN_HPP_NOEXCEPT {
+  return DeviceDiagnosticsConfigFlagsNV(bit0) ^ bit1;
+}
+
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DeviceDiagnosticsConfigFlagsNV
+operator~(DeviceDiagnosticsConfigFlagBitsNV bits) VULKAN_HPP_NOEXCEPT {
+  return ~(DeviceDiagnosticsConfigFlagsNV(bits));
+}
+
+VULKAN_HPP_INLINE std::string to_string(DeviceDiagnosticsConfigFlagsNV value) {
+  if (!value)
+    return "{}";
+  std::string result;
+
+  if (value & DeviceDiagnosticsConfigFlagBitsNV::eEnableShaderDebugInfo)
+    result += "EnableShaderDebugInfo | ";
+  if (value & DeviceDiagnosticsConfigFlagBitsNV::eEnableResourceTracking)
+    result += "EnableResourceTracking | ";
+  if (value & DeviceDiagnosticsConfigFlagBitsNV::eEnableAutomaticCheckpoints)
+    result += "EnableAutomaticCheckpoints | ";
+  return "{ " + result.substr(0, result.size() - 3) + " }";
+}
+
+//=== VK_KHR_synchronization2 ===
+
 using PipelineStageFlags2KHR = Flags<PipelineStageFlagBits2KHR>;
 
 template <> struct FlagTraits<PipelineStageFlagBits2KHR> {
@@ -17333,7 +19177,6 @@
 }
 
 VULKAN_HPP_INLINE std::string to_string(PipelineStageFlags2KHR value) {
-
   if (!value)
     return "{}";
   std::string result;
@@ -17407,897 +19250,133 @@
   return "{ " + result.substr(0, result.size() - 3) + " }";
 }
 
-enum class PipelineTessellationStateCreateFlagBits : VkFlags {};
+using AccessFlags2KHR = Flags<AccessFlagBits2KHR>;
 
-VULKAN_HPP_INLINE std::string
-to_string(PipelineTessellationStateCreateFlagBits) {
-  return "(void)";
-}
-
-using PipelineTessellationStateCreateFlags =
-    Flags<PipelineTessellationStateCreateFlagBits>;
-
-VULKAN_HPP_INLINE std::string to_string(PipelineTessellationStateCreateFlags) {
-
-  return "{}";
-}
-
-enum class PipelineVertexInputStateCreateFlagBits : VkFlags {};
-
-VULKAN_HPP_INLINE std::string
-to_string(PipelineVertexInputStateCreateFlagBits) {
-  return "(void)";
-}
-
-using PipelineVertexInputStateCreateFlags =
-    Flags<PipelineVertexInputStateCreateFlagBits>;
-
-VULKAN_HPP_INLINE std::string to_string(PipelineVertexInputStateCreateFlags) {
-
-  return "{}";
-}
-
-enum class PipelineViewportStateCreateFlagBits : VkFlags {};
-
-VULKAN_HPP_INLINE std::string to_string(PipelineViewportStateCreateFlagBits) {
-  return "(void)";
-}
-
-using PipelineViewportStateCreateFlags =
-    Flags<PipelineViewportStateCreateFlagBits>;
-
-VULKAN_HPP_INLINE std::string to_string(PipelineViewportStateCreateFlags) {
-
-  return "{}";
-}
-
-enum class PipelineViewportSwizzleStateCreateFlagBitsNV : VkFlags {};
-
-VULKAN_HPP_INLINE std::string
-to_string(PipelineViewportSwizzleStateCreateFlagBitsNV) {
-  return "(void)";
-}
-
-using PipelineViewportSwizzleStateCreateFlagsNV =
-    Flags<PipelineViewportSwizzleStateCreateFlagBitsNV>;
-
-VULKAN_HPP_INLINE std::string
-to_string(PipelineViewportSwizzleStateCreateFlagsNV) {
-
-  return "{}";
-}
-
-using PrivateDataSlotCreateFlagsEXT = Flags<PrivateDataSlotCreateFlagBitsEXT>;
-
-VULKAN_HPP_INLINE std::string to_string(PrivateDataSlotCreateFlagsEXT) {
-
-  return "{}";
-}
-
-using QueryControlFlags = Flags<QueryControlFlagBits>;
-
-template <> struct FlagTraits<QueryControlFlagBits> {
-  enum : VkFlags { allFlags = VkFlags(QueryControlFlagBits::ePrecise) };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR QueryControlFlags operator|(
-    QueryControlFlagBits bit0, QueryControlFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return QueryControlFlags(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR QueryControlFlags operator&(
-    QueryControlFlagBits bit0, QueryControlFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return QueryControlFlags(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR QueryControlFlags operator^(
-    QueryControlFlagBits bit0, QueryControlFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return QueryControlFlags(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR QueryControlFlags
-operator~(QueryControlFlagBits bits) VULKAN_HPP_NOEXCEPT {
-  return ~(QueryControlFlags(bits));
-}
-
-VULKAN_HPP_INLINE std::string to_string(QueryControlFlags value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & QueryControlFlagBits::ePrecise)
-    result += "Precise | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-using QueryPipelineStatisticFlags = Flags<QueryPipelineStatisticFlagBits>;
-
-template <> struct FlagTraits<QueryPipelineStatisticFlagBits> {
-  enum : VkFlags {
+template <> struct FlagTraits<AccessFlagBits2KHR> {
+  enum : VkFlags64 {
     allFlags =
-        VkFlags(QueryPipelineStatisticFlagBits::eInputAssemblyVertices) |
-        VkFlags(QueryPipelineStatisticFlagBits::eInputAssemblyPrimitives) |
-        VkFlags(QueryPipelineStatisticFlagBits::eVertexShaderInvocations) |
-        VkFlags(QueryPipelineStatisticFlagBits::eGeometryShaderInvocations) |
-        VkFlags(QueryPipelineStatisticFlagBits::eGeometryShaderPrimitives) |
-        VkFlags(QueryPipelineStatisticFlagBits::eClippingInvocations) |
-        VkFlags(QueryPipelineStatisticFlagBits::eClippingPrimitives) |
-        VkFlags(QueryPipelineStatisticFlagBits::eFragmentShaderInvocations) |
-        VkFlags(
-            QueryPipelineStatisticFlagBits::eTessellationControlShaderPatches) |
-        VkFlags(QueryPipelineStatisticFlagBits::
-                    eTessellationEvaluationShaderInvocations) |
-        VkFlags(QueryPipelineStatisticFlagBits::eComputeShaderInvocations)
+        VkFlags64(AccessFlagBits2KHR::eNone) |
+        VkFlags64(AccessFlagBits2KHR::eIndirectCommandRead) |
+        VkFlags64(AccessFlagBits2KHR::eIndexRead) |
+        VkFlags64(AccessFlagBits2KHR::eVertexAttributeRead) |
+        VkFlags64(AccessFlagBits2KHR::eUniformRead) |
+        VkFlags64(AccessFlagBits2KHR::eInputAttachmentRead) |
+        VkFlags64(AccessFlagBits2KHR::eShaderRead) |
+        VkFlags64(AccessFlagBits2KHR::eShaderWrite) |
+        VkFlags64(AccessFlagBits2KHR::eColorAttachmentRead) |
+        VkFlags64(AccessFlagBits2KHR::eColorAttachmentWrite) |
+        VkFlags64(AccessFlagBits2KHR::eDepthStencilAttachmentRead) |
+        VkFlags64(AccessFlagBits2KHR::eDepthStencilAttachmentWrite) |
+        VkFlags64(AccessFlagBits2KHR::eTransferRead) |
+        VkFlags64(AccessFlagBits2KHR::eTransferWrite) |
+        VkFlags64(AccessFlagBits2KHR::eHostRead) |
+        VkFlags64(AccessFlagBits2KHR::eHostWrite) |
+        VkFlags64(AccessFlagBits2KHR::eMemoryRead) |
+        VkFlags64(AccessFlagBits2KHR::eMemoryWrite) |
+        VkFlags64(AccessFlagBits2KHR::eShaderSampledRead) |
+        VkFlags64(AccessFlagBits2KHR::eShaderStorageRead) |
+        VkFlags64(AccessFlagBits2KHR::eShaderStorageWrite) |
+        VkFlags64(AccessFlagBits2KHR::eTransformFeedbackWriteExt) |
+        VkFlags64(AccessFlagBits2KHR::eTransformFeedbackCounterReadExt) |
+        VkFlags64(AccessFlagBits2KHR::eTransformFeedbackCounterWriteExt) |
+        VkFlags64(AccessFlagBits2KHR::eConditionalRenderingReadExt) |
+        VkFlags64(AccessFlagBits2KHR::eCommandPreprocessReadNv) |
+        VkFlags64(AccessFlagBits2KHR::eCommandPreprocessWriteNv) |
+        VkFlags64(AccessFlagBits2KHR::eFragmentShadingRateAttachmentRead) |
+        VkFlags64(AccessFlagBits2KHR::eAccelerationStructureRead) |
+        VkFlags64(AccessFlagBits2KHR::eAccelerationStructureWrite) |
+        VkFlags64(AccessFlagBits2KHR::eFragmentDensityMapReadExt) |
+        VkFlags64(AccessFlagBits2KHR::eColorAttachmentReadNoncoherentExt)
   };
 };
 
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR QueryPipelineStatisticFlags
-operator|(QueryPipelineStatisticFlagBits bit0,
-          QueryPipelineStatisticFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return QueryPipelineStatisticFlags(bit0) | bit1;
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR AccessFlags2KHR operator|(
+    AccessFlagBits2KHR bit0, AccessFlagBits2KHR bit1) VULKAN_HPP_NOEXCEPT {
+  return AccessFlags2KHR(bit0) | bit1;
 }
 
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR QueryPipelineStatisticFlags
-operator&(QueryPipelineStatisticFlagBits bit0,
-          QueryPipelineStatisticFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return QueryPipelineStatisticFlags(bit0) & bit1;
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR AccessFlags2KHR operator&(
+    AccessFlagBits2KHR bit0, AccessFlagBits2KHR bit1) VULKAN_HPP_NOEXCEPT {
+  return AccessFlags2KHR(bit0) & bit1;
 }
 
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR QueryPipelineStatisticFlags
-operator^(QueryPipelineStatisticFlagBits bit0,
-          QueryPipelineStatisticFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return QueryPipelineStatisticFlags(bit0) ^ bit1;
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR AccessFlags2KHR operator^(
+    AccessFlagBits2KHR bit0, AccessFlagBits2KHR bit1) VULKAN_HPP_NOEXCEPT {
+  return AccessFlags2KHR(bit0) ^ bit1;
 }
 
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR QueryPipelineStatisticFlags
-operator~(QueryPipelineStatisticFlagBits bits) VULKAN_HPP_NOEXCEPT {
-  return ~(QueryPipelineStatisticFlags(bits));
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR AccessFlags2KHR
+operator~(AccessFlagBits2KHR bits) VULKAN_HPP_NOEXCEPT {
+  return ~(AccessFlags2KHR(bits));
 }
 
-VULKAN_HPP_INLINE std::string to_string(QueryPipelineStatisticFlags value) {
-
+VULKAN_HPP_INLINE std::string to_string(AccessFlags2KHR value) {
   if (!value)
     return "{}";
   std::string result;
 
-  if (value & QueryPipelineStatisticFlagBits::eInputAssemblyVertices)
-    result += "InputAssemblyVertices | ";
-  if (value & QueryPipelineStatisticFlagBits::eInputAssemblyPrimitives)
-    result += "InputAssemblyPrimitives | ";
-  if (value & QueryPipelineStatisticFlagBits::eVertexShaderInvocations)
-    result += "VertexShaderInvocations | ";
-  if (value & QueryPipelineStatisticFlagBits::eGeometryShaderInvocations)
-    result += "GeometryShaderInvocations | ";
-  if (value & QueryPipelineStatisticFlagBits::eGeometryShaderPrimitives)
-    result += "GeometryShaderPrimitives | ";
-  if (value & QueryPipelineStatisticFlagBits::eClippingInvocations)
-    result += "ClippingInvocations | ";
-  if (value & QueryPipelineStatisticFlagBits::eClippingPrimitives)
-    result += "ClippingPrimitives | ";
-  if (value & QueryPipelineStatisticFlagBits::eFragmentShaderInvocations)
-    result += "FragmentShaderInvocations | ";
-  if (value & QueryPipelineStatisticFlagBits::eTessellationControlShaderPatches)
-    result += "TessellationControlShaderPatches | ";
-  if (value &
-      QueryPipelineStatisticFlagBits::eTessellationEvaluationShaderInvocations)
-    result += "TessellationEvaluationShaderInvocations | ";
-  if (value & QueryPipelineStatisticFlagBits::eComputeShaderInvocations)
-    result += "ComputeShaderInvocations | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-using QueryPoolCreateFlags = Flags<QueryPoolCreateFlagBits>;
-
-VULKAN_HPP_INLINE std::string to_string(QueryPoolCreateFlags) { return "{}"; }
-
-using QueryResultFlags = Flags<QueryResultFlagBits>;
-
-template <> struct FlagTraits<QueryResultFlagBits> {
-  enum : VkFlags {
-    allFlags = VkFlags(QueryResultFlagBits::e64) |
-               VkFlags(QueryResultFlagBits::eWait) |
-               VkFlags(QueryResultFlagBits::eWithAvailability) |
-               VkFlags(QueryResultFlagBits::ePartial)
-  };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR QueryResultFlags operator|(
-    QueryResultFlagBits bit0, QueryResultFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return QueryResultFlags(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR QueryResultFlags operator&(
-    QueryResultFlagBits bit0, QueryResultFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return QueryResultFlags(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR QueryResultFlags operator^(
-    QueryResultFlagBits bit0, QueryResultFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return QueryResultFlags(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR QueryResultFlags
-operator~(QueryResultFlagBits bits) VULKAN_HPP_NOEXCEPT {
-  return ~(QueryResultFlags(bits));
-}
-
-VULKAN_HPP_INLINE std::string to_string(QueryResultFlags value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & QueryResultFlagBits::e64)
-    result += "64 | ";
-  if (value & QueryResultFlagBits::eWait)
-    result += "Wait | ";
-  if (value & QueryResultFlagBits::eWithAvailability)
-    result += "WithAvailability | ";
-  if (value & QueryResultFlagBits::ePartial)
-    result += "Partial | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-using QueueFlags = Flags<QueueFlagBits>;
-
-template <> struct FlagTraits<QueueFlagBits> {
-  enum : VkFlags {
-    allFlags = VkFlags(QueueFlagBits::eGraphics) |
-               VkFlags(QueueFlagBits::eCompute) |
-               VkFlags(QueueFlagBits::eTransfer) |
-               VkFlags(QueueFlagBits::eSparseBinding) |
-               VkFlags(QueueFlagBits::eProtected)
-  };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR QueueFlags
-operator|(QueueFlagBits bit0, QueueFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return QueueFlags(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR QueueFlags
-operator&(QueueFlagBits bit0, QueueFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return QueueFlags(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR QueueFlags
-operator^(QueueFlagBits bit0, QueueFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return QueueFlags(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR QueueFlags operator~(QueueFlagBits bits)
-    VULKAN_HPP_NOEXCEPT {
-  return ~(QueueFlags(bits));
-}
-
-VULKAN_HPP_INLINE std::string to_string(QueueFlags value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & QueueFlagBits::eGraphics)
-    result += "Graphics | ";
-  if (value & QueueFlagBits::eCompute)
-    result += "Compute | ";
-  if (value & QueueFlagBits::eTransfer)
-    result += "Transfer | ";
-  if (value & QueueFlagBits::eSparseBinding)
-    result += "SparseBinding | ";
-  if (value & QueueFlagBits::eProtected)
-    result += "Protected | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-using RenderPassCreateFlags = Flags<RenderPassCreateFlagBits>;
-
-template <> struct FlagTraits<RenderPassCreateFlagBits> {
-  enum : VkFlags {
-    allFlags = VkFlags(RenderPassCreateFlagBits::eTransformQCOM)
-  };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR RenderPassCreateFlags
-operator|(RenderPassCreateFlagBits bit0,
-          RenderPassCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return RenderPassCreateFlags(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR RenderPassCreateFlags
-operator&(RenderPassCreateFlagBits bit0,
-          RenderPassCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return RenderPassCreateFlags(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR RenderPassCreateFlags
-operator^(RenderPassCreateFlagBits bit0,
-          RenderPassCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return RenderPassCreateFlags(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR RenderPassCreateFlags
-operator~(RenderPassCreateFlagBits bits) VULKAN_HPP_NOEXCEPT {
-  return ~(RenderPassCreateFlags(bits));
-}
-
-VULKAN_HPP_INLINE std::string to_string(RenderPassCreateFlags value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & RenderPassCreateFlagBits::eTransformQCOM)
-    result += "TransformQCOM | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-using ResolveModeFlags = Flags<ResolveModeFlagBits>;
-
-template <> struct FlagTraits<ResolveModeFlagBits> {
-  enum : VkFlags {
-    allFlags = VkFlags(ResolveModeFlagBits::eNone) |
-               VkFlags(ResolveModeFlagBits::eSampleZero) |
-               VkFlags(ResolveModeFlagBits::eAverage) |
-               VkFlags(ResolveModeFlagBits::eMin) |
-               VkFlags(ResolveModeFlagBits::eMax)
-  };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ResolveModeFlags operator|(
-    ResolveModeFlagBits bit0, ResolveModeFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return ResolveModeFlags(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ResolveModeFlags operator&(
-    ResolveModeFlagBits bit0, ResolveModeFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return ResolveModeFlags(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ResolveModeFlags operator^(
-    ResolveModeFlagBits bit0, ResolveModeFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return ResolveModeFlags(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ResolveModeFlags
-operator~(ResolveModeFlagBits bits) VULKAN_HPP_NOEXCEPT {
-  return ~(ResolveModeFlags(bits));
-}
-
-using ResolveModeFlagsKHR = ResolveModeFlags;
-
-VULKAN_HPP_INLINE std::string to_string(ResolveModeFlags value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & ResolveModeFlagBits::eSampleZero)
-    result += "SampleZero | ";
-  if (value & ResolveModeFlagBits::eAverage)
-    result += "Average | ";
-  if (value & ResolveModeFlagBits::eMin)
-    result += "Min | ";
-  if (value & ResolveModeFlagBits::eMax)
-    result += "Max | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-using SampleCountFlags = Flags<SampleCountFlagBits>;
-
-template <> struct FlagTraits<SampleCountFlagBits> {
-  enum : VkFlags {
-    allFlags =
-        VkFlags(SampleCountFlagBits::e1) | VkFlags(SampleCountFlagBits::e2) |
-        VkFlags(SampleCountFlagBits::e4) | VkFlags(SampleCountFlagBits::e8) |
-        VkFlags(SampleCountFlagBits::e16) | VkFlags(SampleCountFlagBits::e32) |
-        VkFlags(SampleCountFlagBits::e64)
-  };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SampleCountFlags operator|(
-    SampleCountFlagBits bit0, SampleCountFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return SampleCountFlags(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SampleCountFlags operator&(
-    SampleCountFlagBits bit0, SampleCountFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return SampleCountFlags(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SampleCountFlags operator^(
-    SampleCountFlagBits bit0, SampleCountFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return SampleCountFlags(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SampleCountFlags
-operator~(SampleCountFlagBits bits) VULKAN_HPP_NOEXCEPT {
-  return ~(SampleCountFlags(bits));
-}
-
-VULKAN_HPP_INLINE std::string to_string(SampleCountFlags value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & SampleCountFlagBits::e1)
-    result += "1 | ";
-  if (value & SampleCountFlagBits::e2)
-    result += "2 | ";
-  if (value & SampleCountFlagBits::e4)
-    result += "4 | ";
-  if (value & SampleCountFlagBits::e8)
-    result += "8 | ";
-  if (value & SampleCountFlagBits::e16)
-    result += "16 | ";
-  if (value & SampleCountFlagBits::e32)
-    result += "32 | ";
-  if (value & SampleCountFlagBits::e64)
-    result += "64 | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-using SamplerCreateFlags = Flags<SamplerCreateFlagBits>;
-
-template <> struct FlagTraits<SamplerCreateFlagBits> {
-  enum : VkFlags {
-    allFlags =
-        VkFlags(SamplerCreateFlagBits::eSubsampledEXT) |
-        VkFlags(SamplerCreateFlagBits::eSubsampledCoarseReconstructionEXT)
-  };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SamplerCreateFlags
-operator|(SamplerCreateFlagBits bit0,
-          SamplerCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return SamplerCreateFlags(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SamplerCreateFlags
-operator&(SamplerCreateFlagBits bit0,
-          SamplerCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return SamplerCreateFlags(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SamplerCreateFlags
-operator^(SamplerCreateFlagBits bit0,
-          SamplerCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return SamplerCreateFlags(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SamplerCreateFlags
-operator~(SamplerCreateFlagBits bits) VULKAN_HPP_NOEXCEPT {
-  return ~(SamplerCreateFlags(bits));
-}
-
-VULKAN_HPP_INLINE std::string to_string(SamplerCreateFlags value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & SamplerCreateFlagBits::eSubsampledEXT)
-    result += "SubsampledEXT | ";
-  if (value & SamplerCreateFlagBits::eSubsampledCoarseReconstructionEXT)
-    result += "SubsampledCoarseReconstructionEXT | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-#if defined(VK_USE_PLATFORM_SCREEN_QNX)
-enum class ScreenSurfaceCreateFlagBitsQNX : VkFlags {};
-
-VULKAN_HPP_INLINE std::string to_string(ScreenSurfaceCreateFlagBitsQNX) {
-  return "(void)";
-}
-
-using ScreenSurfaceCreateFlagsQNX = Flags<ScreenSurfaceCreateFlagBitsQNX>;
-
-VULKAN_HPP_INLINE std::string to_string(ScreenSurfaceCreateFlagsQNX) {
-
-  return "{}";
-}
-#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
-
-enum class SemaphoreCreateFlagBits : VkFlags {};
-
-VULKAN_HPP_INLINE std::string to_string(SemaphoreCreateFlagBits) {
-  return "(void)";
-}
-
-using SemaphoreCreateFlags = Flags<SemaphoreCreateFlagBits>;
-
-VULKAN_HPP_INLINE std::string to_string(SemaphoreCreateFlags) { return "{}"; }
-
-using SemaphoreImportFlags = Flags<SemaphoreImportFlagBits>;
-
-template <> struct FlagTraits<SemaphoreImportFlagBits> {
-  enum : VkFlags { allFlags = VkFlags(SemaphoreImportFlagBits::eTemporary) };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SemaphoreImportFlags
-operator|(SemaphoreImportFlagBits bit0,
-          SemaphoreImportFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return SemaphoreImportFlags(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SemaphoreImportFlags
-operator&(SemaphoreImportFlagBits bit0,
-          SemaphoreImportFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return SemaphoreImportFlags(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SemaphoreImportFlags
-operator^(SemaphoreImportFlagBits bit0,
-          SemaphoreImportFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return SemaphoreImportFlags(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SemaphoreImportFlags
-operator~(SemaphoreImportFlagBits bits) VULKAN_HPP_NOEXCEPT {
-  return ~(SemaphoreImportFlags(bits));
-}
-
-using SemaphoreImportFlagsKHR = SemaphoreImportFlags;
-
-VULKAN_HPP_INLINE std::string to_string(SemaphoreImportFlags value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & SemaphoreImportFlagBits::eTemporary)
-    result += "Temporary | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-using SemaphoreWaitFlags = Flags<SemaphoreWaitFlagBits>;
-
-template <> struct FlagTraits<SemaphoreWaitFlagBits> {
-  enum : VkFlags { allFlags = VkFlags(SemaphoreWaitFlagBits::eAny) };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SemaphoreWaitFlags
-operator|(SemaphoreWaitFlagBits bit0,
-          SemaphoreWaitFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return SemaphoreWaitFlags(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SemaphoreWaitFlags
-operator&(SemaphoreWaitFlagBits bit0,
-          SemaphoreWaitFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return SemaphoreWaitFlags(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SemaphoreWaitFlags
-operator^(SemaphoreWaitFlagBits bit0,
-          SemaphoreWaitFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return SemaphoreWaitFlags(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SemaphoreWaitFlags
-operator~(SemaphoreWaitFlagBits bits) VULKAN_HPP_NOEXCEPT {
-  return ~(SemaphoreWaitFlags(bits));
-}
-
-using SemaphoreWaitFlagsKHR = SemaphoreWaitFlags;
-
-VULKAN_HPP_INLINE std::string to_string(SemaphoreWaitFlags value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & SemaphoreWaitFlagBits::eAny)
-    result += "Any | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-using ShaderCorePropertiesFlagsAMD = Flags<ShaderCorePropertiesFlagBitsAMD>;
-
-VULKAN_HPP_INLINE std::string to_string(ShaderCorePropertiesFlagsAMD) {
-
-  return "{}";
-}
-
-using ShaderModuleCreateFlags = Flags<ShaderModuleCreateFlagBits>;
-
-VULKAN_HPP_INLINE std::string to_string(ShaderModuleCreateFlags) {
-
-  return "{}";
-}
-
-using ShaderStageFlags = Flags<ShaderStageFlagBits>;
-
-template <> struct FlagTraits<ShaderStageFlagBits> {
-  enum : VkFlags {
-    allFlags = VkFlags(ShaderStageFlagBits::eVertex) |
-               VkFlags(ShaderStageFlagBits::eTessellationControl) |
-               VkFlags(ShaderStageFlagBits::eTessellationEvaluation) |
-               VkFlags(ShaderStageFlagBits::eGeometry) |
-               VkFlags(ShaderStageFlagBits::eFragment) |
-               VkFlags(ShaderStageFlagBits::eCompute) |
-               VkFlags(ShaderStageFlagBits::eAllGraphics) |
-               VkFlags(ShaderStageFlagBits::eAll) |
-               VkFlags(ShaderStageFlagBits::eRaygenKHR) |
-               VkFlags(ShaderStageFlagBits::eAnyHitKHR) |
-               VkFlags(ShaderStageFlagBits::eClosestHitKHR) |
-               VkFlags(ShaderStageFlagBits::eMissKHR) |
-               VkFlags(ShaderStageFlagBits::eIntersectionKHR) |
-               VkFlags(ShaderStageFlagBits::eCallableKHR) |
-               VkFlags(ShaderStageFlagBits::eTaskNV) |
-               VkFlags(ShaderStageFlagBits::eMeshNV)
-  };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ShaderStageFlags operator|(
-    ShaderStageFlagBits bit0, ShaderStageFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return ShaderStageFlags(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ShaderStageFlags operator&(
-    ShaderStageFlagBits bit0, ShaderStageFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return ShaderStageFlags(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ShaderStageFlags operator^(
-    ShaderStageFlagBits bit0, ShaderStageFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return ShaderStageFlags(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ShaderStageFlags
-operator~(ShaderStageFlagBits bits) VULKAN_HPP_NOEXCEPT {
-  return ~(ShaderStageFlags(bits));
-}
-
-VULKAN_HPP_INLINE std::string to_string(ShaderStageFlags value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & ShaderStageFlagBits::eVertex)
-    result += "Vertex | ";
-  if (value & ShaderStageFlagBits::eTessellationControl)
-    result += "TessellationControl | ";
-  if (value & ShaderStageFlagBits::eTessellationEvaluation)
-    result += "TessellationEvaluation | ";
-  if (value & ShaderStageFlagBits::eGeometry)
-    result += "Geometry | ";
-  if (value & ShaderStageFlagBits::eFragment)
-    result += "Fragment | ";
-  if (value & ShaderStageFlagBits::eCompute)
-    result += "Compute | ";
-  if (value & ShaderStageFlagBits::eRaygenKHR)
-    result += "RaygenKHR | ";
-  if (value & ShaderStageFlagBits::eAnyHitKHR)
-    result += "AnyHitKHR | ";
-  if (value & ShaderStageFlagBits::eClosestHitKHR)
-    result += "ClosestHitKHR | ";
-  if (value & ShaderStageFlagBits::eMissKHR)
-    result += "MissKHR | ";
-  if (value & ShaderStageFlagBits::eIntersectionKHR)
-    result += "IntersectionKHR | ";
-  if (value & ShaderStageFlagBits::eCallableKHR)
-    result += "CallableKHR | ";
-  if (value & ShaderStageFlagBits::eTaskNV)
-    result += "TaskNV | ";
-  if (value & ShaderStageFlagBits::eMeshNV)
-    result += "MeshNV | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-using SparseImageFormatFlags = Flags<SparseImageFormatFlagBits>;
-
-template <> struct FlagTraits<SparseImageFormatFlagBits> {
-  enum : VkFlags {
-    allFlags = VkFlags(SparseImageFormatFlagBits::eSingleMiptail) |
-               VkFlags(SparseImageFormatFlagBits::eAlignedMipSize) |
-               VkFlags(SparseImageFormatFlagBits::eNonstandardBlockSize)
-  };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SparseImageFormatFlags
-operator|(SparseImageFormatFlagBits bit0,
-          SparseImageFormatFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return SparseImageFormatFlags(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SparseImageFormatFlags
-operator&(SparseImageFormatFlagBits bit0,
-          SparseImageFormatFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return SparseImageFormatFlags(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SparseImageFormatFlags
-operator^(SparseImageFormatFlagBits bit0,
-          SparseImageFormatFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return SparseImageFormatFlags(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SparseImageFormatFlags
-operator~(SparseImageFormatFlagBits bits) VULKAN_HPP_NOEXCEPT {
-  return ~(SparseImageFormatFlags(bits));
-}
-
-VULKAN_HPP_INLINE std::string to_string(SparseImageFormatFlags value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & SparseImageFormatFlagBits::eSingleMiptail)
-    result += "SingleMiptail | ";
-  if (value & SparseImageFormatFlagBits::eAlignedMipSize)
-    result += "AlignedMipSize | ";
-  if (value & SparseImageFormatFlagBits::eNonstandardBlockSize)
-    result += "NonstandardBlockSize | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-using SparseMemoryBindFlags = Flags<SparseMemoryBindFlagBits>;
-
-template <> struct FlagTraits<SparseMemoryBindFlagBits> {
-  enum : VkFlags { allFlags = VkFlags(SparseMemoryBindFlagBits::eMetadata) };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SparseMemoryBindFlags
-operator|(SparseMemoryBindFlagBits bit0,
-          SparseMemoryBindFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return SparseMemoryBindFlags(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SparseMemoryBindFlags
-operator&(SparseMemoryBindFlagBits bit0,
-          SparseMemoryBindFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return SparseMemoryBindFlags(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SparseMemoryBindFlags
-operator^(SparseMemoryBindFlagBits bit0,
-          SparseMemoryBindFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return SparseMemoryBindFlags(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SparseMemoryBindFlags
-operator~(SparseMemoryBindFlagBits bits) VULKAN_HPP_NOEXCEPT {
-  return ~(SparseMemoryBindFlags(bits));
-}
-
-VULKAN_HPP_INLINE std::string to_string(SparseMemoryBindFlags value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & SparseMemoryBindFlagBits::eMetadata)
-    result += "Metadata | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-using StencilFaceFlags = Flags<StencilFaceFlagBits>;
-
-template <> struct FlagTraits<StencilFaceFlagBits> {
-  enum : VkFlags {
-    allFlags = VkFlags(StencilFaceFlagBits::eFront) |
-               VkFlags(StencilFaceFlagBits::eBack) |
-               VkFlags(StencilFaceFlagBits::eFrontAndBack)
-  };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR StencilFaceFlags operator|(
-    StencilFaceFlagBits bit0, StencilFaceFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return StencilFaceFlags(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR StencilFaceFlags operator&(
-    StencilFaceFlagBits bit0, StencilFaceFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return StencilFaceFlags(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR StencilFaceFlags operator^(
-    StencilFaceFlagBits bit0, StencilFaceFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return StencilFaceFlags(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR StencilFaceFlags
-operator~(StencilFaceFlagBits bits) VULKAN_HPP_NOEXCEPT {
-  return ~(StencilFaceFlags(bits));
-}
-
-VULKAN_HPP_INLINE std::string to_string(StencilFaceFlags value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & StencilFaceFlagBits::eFront)
-    result += "Front | ";
-  if (value & StencilFaceFlagBits::eBack)
-    result += "Back | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-#if defined(VK_USE_PLATFORM_GGP)
-enum class StreamDescriptorSurfaceCreateFlagBitsGGP : VkFlags {};
-
-VULKAN_HPP_INLINE std::string
-to_string(StreamDescriptorSurfaceCreateFlagBitsGGP) {
-  return "(void)";
-}
-
-using StreamDescriptorSurfaceCreateFlagsGGP =
-    Flags<StreamDescriptorSurfaceCreateFlagBitsGGP>;
-
-VULKAN_HPP_INLINE std::string to_string(StreamDescriptorSurfaceCreateFlagsGGP) {
-
-  return "{}";
-}
-#endif /*VK_USE_PLATFORM_GGP*/
-
-using SubgroupFeatureFlags = Flags<SubgroupFeatureFlagBits>;
-
-template <> struct FlagTraits<SubgroupFeatureFlagBits> {
-  enum : VkFlags {
-    allFlags = VkFlags(SubgroupFeatureFlagBits::eBasic) |
-               VkFlags(SubgroupFeatureFlagBits::eVote) |
-               VkFlags(SubgroupFeatureFlagBits::eArithmetic) |
-               VkFlags(SubgroupFeatureFlagBits::eBallot) |
-               VkFlags(SubgroupFeatureFlagBits::eShuffle) |
-               VkFlags(SubgroupFeatureFlagBits::eShuffleRelative) |
-               VkFlags(SubgroupFeatureFlagBits::eClustered) |
-               VkFlags(SubgroupFeatureFlagBits::eQuad) |
-               VkFlags(SubgroupFeatureFlagBits::ePartitionedNV)
-  };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SubgroupFeatureFlags
-operator|(SubgroupFeatureFlagBits bit0,
-          SubgroupFeatureFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return SubgroupFeatureFlags(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SubgroupFeatureFlags
-operator&(SubgroupFeatureFlagBits bit0,
-          SubgroupFeatureFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return SubgroupFeatureFlags(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SubgroupFeatureFlags
-operator^(SubgroupFeatureFlagBits bit0,
-          SubgroupFeatureFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return SubgroupFeatureFlags(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SubgroupFeatureFlags
-operator~(SubgroupFeatureFlagBits bits) VULKAN_HPP_NOEXCEPT {
-  return ~(SubgroupFeatureFlags(bits));
-}
-
-VULKAN_HPP_INLINE std::string to_string(SubgroupFeatureFlags value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & SubgroupFeatureFlagBits::eBasic)
-    result += "Basic | ";
-  if (value & SubgroupFeatureFlagBits::eVote)
-    result += "Vote | ";
-  if (value & SubgroupFeatureFlagBits::eArithmetic)
-    result += "Arithmetic | ";
-  if (value & SubgroupFeatureFlagBits::eBallot)
-    result += "Ballot | ";
-  if (value & SubgroupFeatureFlagBits::eShuffle)
-    result += "Shuffle | ";
-  if (value & SubgroupFeatureFlagBits::eShuffleRelative)
-    result += "ShuffleRelative | ";
-  if (value & SubgroupFeatureFlagBits::eClustered)
-    result += "Clustered | ";
-  if (value & SubgroupFeatureFlagBits::eQuad)
-    result += "Quad | ";
-  if (value & SubgroupFeatureFlagBits::ePartitionedNV)
-    result += "PartitionedNV | ";
+  if (value & AccessFlagBits2KHR::eIndirectCommandRead)
+    result += "IndirectCommandRead | ";
+  if (value & AccessFlagBits2KHR::eIndexRead)
+    result += "IndexRead | ";
+  if (value & AccessFlagBits2KHR::eVertexAttributeRead)
+    result += "VertexAttributeRead | ";
+  if (value & AccessFlagBits2KHR::eUniformRead)
+    result += "UniformRead | ";
+  if (value & AccessFlagBits2KHR::eInputAttachmentRead)
+    result += "InputAttachmentRead | ";
+  if (value & AccessFlagBits2KHR::eShaderRead)
+    result += "ShaderRead | ";
+  if (value & AccessFlagBits2KHR::eShaderWrite)
+    result += "ShaderWrite | ";
+  if (value & AccessFlagBits2KHR::eColorAttachmentRead)
+    result += "ColorAttachmentRead | ";
+  if (value & AccessFlagBits2KHR::eColorAttachmentWrite)
+    result += "ColorAttachmentWrite | ";
+  if (value & AccessFlagBits2KHR::eDepthStencilAttachmentRead)
+    result += "DepthStencilAttachmentRead | ";
+  if (value & AccessFlagBits2KHR::eDepthStencilAttachmentWrite)
+    result += "DepthStencilAttachmentWrite | ";
+  if (value & AccessFlagBits2KHR::eTransferRead)
+    result += "TransferRead | ";
+  if (value & AccessFlagBits2KHR::eTransferWrite)
+    result += "TransferWrite | ";
+  if (value & AccessFlagBits2KHR::eHostRead)
+    result += "HostRead | ";
+  if (value & AccessFlagBits2KHR::eHostWrite)
+    result += "HostWrite | ";
+  if (value & AccessFlagBits2KHR::eMemoryRead)
+    result += "MemoryRead | ";
+  if (value & AccessFlagBits2KHR::eMemoryWrite)
+    result += "MemoryWrite | ";
+  if (value & AccessFlagBits2KHR::eShaderSampledRead)
+    result += "ShaderSampledRead | ";
+  if (value & AccessFlagBits2KHR::eShaderStorageRead)
+    result += "ShaderStorageRead | ";
+  if (value & AccessFlagBits2KHR::eShaderStorageWrite)
+    result += "ShaderStorageWrite | ";
+  if (value & AccessFlagBits2KHR::eTransformFeedbackWriteExt)
+    result += "TransformFeedbackWriteExt | ";
+  if (value & AccessFlagBits2KHR::eTransformFeedbackCounterReadExt)
+    result += "TransformFeedbackCounterReadExt | ";
+  if (value & AccessFlagBits2KHR::eTransformFeedbackCounterWriteExt)
+    result += "TransformFeedbackCounterWriteExt | ";
+  if (value & AccessFlagBits2KHR::eConditionalRenderingReadExt)
+    result += "ConditionalRenderingReadExt | ";
+  if (value & AccessFlagBits2KHR::eCommandPreprocessReadNv)
+    result += "CommandPreprocessReadNv | ";
+  if (value & AccessFlagBits2KHR::eCommandPreprocessWriteNv)
+    result += "CommandPreprocessWriteNv | ";
+  if (value & AccessFlagBits2KHR::eFragmentShadingRateAttachmentRead)
+    result += "FragmentShadingRateAttachmentRead | ";
+  if (value & AccessFlagBits2KHR::eAccelerationStructureRead)
+    result += "AccelerationStructureRead | ";
+  if (value & AccessFlagBits2KHR::eAccelerationStructureWrite)
+    result += "AccelerationStructureWrite | ";
+  if (value & AccessFlagBits2KHR::eFragmentDensityMapReadExt)
+    result += "FragmentDensityMapReadExt | ";
+  if (value & AccessFlagBits2KHR::eColorAttachmentReadNoncoherentExt)
+    result += "ColorAttachmentReadNoncoherentExt | ";
   return "{ " + result.substr(0, result.size() - 3) + " }";
 }
 
@@ -18328,7 +19407,6 @@
 }
 
 VULKAN_HPP_INLINE std::string to_string(SubmitFlagsKHR value) {
-
   if (!value)
     return "{}";
   std::string result;
@@ -18338,356 +19416,244 @@
   return "{ " + result.substr(0, result.size() - 3) + " }";
 }
 
-using SubpassDescriptionFlags = Flags<SubpassDescriptionFlagBits>;
+#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
 
-template <> struct FlagTraits<SubpassDescriptionFlagBits> {
+//=== VK_EXT_directfb_surface ===
+
+enum class DirectFBSurfaceCreateFlagBitsEXT : VkFlags {};
+
+VULKAN_HPP_INLINE std::string to_string(DirectFBSurfaceCreateFlagBitsEXT) {
+  return "(void)";
+}
+
+using DirectFBSurfaceCreateFlagsEXT = Flags<DirectFBSurfaceCreateFlagBitsEXT>;
+
+VULKAN_HPP_INLINE std::string to_string(DirectFBSurfaceCreateFlagsEXT) {
+  return "{}";
+}
+#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
+
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+
+//=== VK_FUCHSIA_memory_control ===
+
+using MemoryOpFlagsFUCHSIA = Flags<MemoryOpFlagBitsFUCHSIA>;
+
+template <> struct FlagTraits<MemoryOpFlagBitsFUCHSIA> {
   enum : VkFlags {
-    allFlags = VkFlags(SubpassDescriptionFlagBits::ePerViewAttributesNVX) |
-               VkFlags(SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX) |
-               VkFlags(SubpassDescriptionFlagBits::eFragmentRegionQCOM) |
-               VkFlags(SubpassDescriptionFlagBits::eShaderResolveQCOM)
+    allFlags = VkFlags(MemoryOpFlagBitsFUCHSIA::eUnpin) |
+               VkFlags(MemoryOpFlagBitsFUCHSIA::eDecommit) |
+               VkFlags(MemoryOpFlagBitsFUCHSIA::ePin) |
+               VkFlags(MemoryOpFlagBitsFUCHSIA::eCommit) |
+               VkFlags(MemoryOpFlagBitsFUCHSIA::eLock) |
+               VkFlags(MemoryOpFlagBitsFUCHSIA::eUnlock)
   };
 };
 
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SubpassDescriptionFlags
-operator|(SubpassDescriptionFlagBits bit0,
-          SubpassDescriptionFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return SubpassDescriptionFlags(bit0) | bit1;
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR MemoryOpFlagsFUCHSIA
+operator|(MemoryOpFlagBitsFUCHSIA bit0,
+          MemoryOpFlagBitsFUCHSIA bit1) VULKAN_HPP_NOEXCEPT {
+  return MemoryOpFlagsFUCHSIA(bit0) | bit1;
 }
 
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SubpassDescriptionFlags
-operator&(SubpassDescriptionFlagBits bit0,
-          SubpassDescriptionFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return SubpassDescriptionFlags(bit0) & bit1;
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR MemoryOpFlagsFUCHSIA
+operator&(MemoryOpFlagBitsFUCHSIA bit0,
+          MemoryOpFlagBitsFUCHSIA bit1) VULKAN_HPP_NOEXCEPT {
+  return MemoryOpFlagsFUCHSIA(bit0) & bit1;
 }
 
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SubpassDescriptionFlags
-operator^(SubpassDescriptionFlagBits bit0,
-          SubpassDescriptionFlagBits bit1) VULKAN_HPP_NOEXCEPT {
-  return SubpassDescriptionFlags(bit0) ^ bit1;
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR MemoryOpFlagsFUCHSIA
+operator^(MemoryOpFlagBitsFUCHSIA bit0,
+          MemoryOpFlagBitsFUCHSIA bit1) VULKAN_HPP_NOEXCEPT {
+  return MemoryOpFlagsFUCHSIA(bit0) ^ bit1;
 }
 
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SubpassDescriptionFlags
-operator~(SubpassDescriptionFlagBits bits) VULKAN_HPP_NOEXCEPT {
-  return ~(SubpassDescriptionFlags(bits));
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR MemoryOpFlagsFUCHSIA
+operator~(MemoryOpFlagBitsFUCHSIA bits) VULKAN_HPP_NOEXCEPT {
+  return ~(MemoryOpFlagsFUCHSIA(bits));
 }
 
-VULKAN_HPP_INLINE std::string to_string(SubpassDescriptionFlags value) {
-
+VULKAN_HPP_INLINE std::string to_string(MemoryOpFlagsFUCHSIA value) {
   if (!value)
     return "{}";
   std::string result;
 
-  if (value & SubpassDescriptionFlagBits::ePerViewAttributesNVX)
-    result += "PerViewAttributesNVX | ";
-  if (value & SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX)
-    result += "PerViewPositionXOnlyNVX | ";
-  if (value & SubpassDescriptionFlagBits::eFragmentRegionQCOM)
-    result += "FragmentRegionQCOM | ";
-  if (value & SubpassDescriptionFlagBits::eShaderResolveQCOM)
-    result += "ShaderResolveQCOM | ";
+  if (value & MemoryOpFlagBitsFUCHSIA::eUnpin)
+    result += "Unpin | ";
+  if (value & MemoryOpFlagBitsFUCHSIA::eDecommit)
+    result += "Decommit | ";
+  if (value & MemoryOpFlagBitsFUCHSIA::ePin)
+    result += "Pin | ";
+  if (value & MemoryOpFlagBitsFUCHSIA::eCommit)
+    result += "Commit | ";
+  if (value & MemoryOpFlagBitsFUCHSIA::eLock)
+    result += "Lock | ";
+  if (value & MemoryOpFlagBitsFUCHSIA::eUnlock)
+    result += "Unlock | ";
   return "{ " + result.substr(0, result.size() - 3) + " }";
 }
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
 
-using SurfaceCounterFlagsEXT = Flags<SurfaceCounterFlagBitsEXT>;
+#if defined(VK_USE_PLATFORM_FUCHSIA)
 
-template <> struct FlagTraits<SurfaceCounterFlagBitsEXT> {
-  enum : VkFlags { allFlags = VkFlags(SurfaceCounterFlagBitsEXT::eVblank) };
-};
+//=== VK_FUCHSIA_buffer_collection_x ===
 
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SurfaceCounterFlagsEXT
-operator|(SurfaceCounterFlagBitsEXT bit0,
-          SurfaceCounterFlagBitsEXT bit1) VULKAN_HPP_NOEXCEPT {
-  return SurfaceCounterFlagsEXT(bit0) | bit1;
+using ImageFormatConstraintsFlagsFUCHSIAX =
+    Flags<ImageFormatConstraintsFlagBitsFUCHSIAX>;
+
+VULKAN_HPP_INLINE std::string to_string(ImageFormatConstraintsFlagsFUCHSIAX) {
+  return "{}";
 }
 
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SurfaceCounterFlagsEXT
-operator&(SurfaceCounterFlagBitsEXT bit0,
-          SurfaceCounterFlagBitsEXT bit1) VULKAN_HPP_NOEXCEPT {
-  return SurfaceCounterFlagsEXT(bit0) & bit1;
-}
+using ImageConstraintsInfoFlagsFUCHSIAX =
+    Flags<ImageConstraintsInfoFlagBitsFUCHSIAX>;
 
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SurfaceCounterFlagsEXT
-operator^(SurfaceCounterFlagBitsEXT bit0,
-          SurfaceCounterFlagBitsEXT bit1) VULKAN_HPP_NOEXCEPT {
-  return SurfaceCounterFlagsEXT(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SurfaceCounterFlagsEXT
-operator~(SurfaceCounterFlagBitsEXT bits) VULKAN_HPP_NOEXCEPT {
-  return ~(SurfaceCounterFlagsEXT(bits));
-}
-
-VULKAN_HPP_INLINE std::string to_string(SurfaceCounterFlagsEXT value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & SurfaceCounterFlagBitsEXT::eVblank)
-    result += "Vblank | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-using SurfaceTransformFlagsKHR = Flags<SurfaceTransformFlagBitsKHR>;
-
-template <> struct FlagTraits<SurfaceTransformFlagBitsKHR> {
+template <> struct FlagTraits<ImageConstraintsInfoFlagBitsFUCHSIAX> {
   enum : VkFlags {
-    allFlags =
-        VkFlags(SurfaceTransformFlagBitsKHR::eIdentity) |
-        VkFlags(SurfaceTransformFlagBitsKHR::eRotate90) |
-        VkFlags(SurfaceTransformFlagBitsKHR::eRotate180) |
-        VkFlags(SurfaceTransformFlagBitsKHR::eRotate270) |
-        VkFlags(SurfaceTransformFlagBitsKHR::eHorizontalMirror) |
-        VkFlags(SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate90) |
-        VkFlags(SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate180) |
-        VkFlags(SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate270) |
-        VkFlags(SurfaceTransformFlagBitsKHR::eInherit)
+    allFlags = VkFlags(ImageConstraintsInfoFlagBitsFUCHSIAX::
+                           eVkImageConstraintsInfoCpuReadRarelyFuchsiax) |
+               VkFlags(ImageConstraintsInfoFlagBitsFUCHSIAX::
+                           eVkImageConstraintsInfoCpuReadOftenFuchsiax) |
+               VkFlags(ImageConstraintsInfoFlagBitsFUCHSIAX::
+                           eVkImageConstraintsInfoCpuWriteRarelyFuchsiax) |
+               VkFlags(ImageConstraintsInfoFlagBitsFUCHSIAX::
+                           eVkImageConstraintsInfoCpuWriteOftenFuchsiax) |
+               VkFlags(ImageConstraintsInfoFlagBitsFUCHSIAX::
+                           eVkImageConstraintsInfoProtectedOptionalFuchsiax)
   };
 };
 
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SurfaceTransformFlagsKHR
-operator|(SurfaceTransformFlagBitsKHR bit0,
-          SurfaceTransformFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
-  return SurfaceTransformFlagsKHR(bit0) | bit1;
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ImageConstraintsInfoFlagsFUCHSIAX
+operator|(ImageConstraintsInfoFlagBitsFUCHSIAX bit0,
+          ImageConstraintsInfoFlagBitsFUCHSIAX bit1) VULKAN_HPP_NOEXCEPT {
+  return ImageConstraintsInfoFlagsFUCHSIAX(bit0) | bit1;
 }
 
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SurfaceTransformFlagsKHR
-operator&(SurfaceTransformFlagBitsKHR bit0,
-          SurfaceTransformFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
-  return SurfaceTransformFlagsKHR(bit0) & bit1;
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ImageConstraintsInfoFlagsFUCHSIAX
+operator&(ImageConstraintsInfoFlagBitsFUCHSIAX bit0,
+          ImageConstraintsInfoFlagBitsFUCHSIAX bit1) VULKAN_HPP_NOEXCEPT {
+  return ImageConstraintsInfoFlagsFUCHSIAX(bit0) & bit1;
 }
 
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SurfaceTransformFlagsKHR
-operator^(SurfaceTransformFlagBitsKHR bit0,
-          SurfaceTransformFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
-  return SurfaceTransformFlagsKHR(bit0) ^ bit1;
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ImageConstraintsInfoFlagsFUCHSIAX
+operator^(ImageConstraintsInfoFlagBitsFUCHSIAX bit0,
+          ImageConstraintsInfoFlagBitsFUCHSIAX bit1) VULKAN_HPP_NOEXCEPT {
+  return ImageConstraintsInfoFlagsFUCHSIAX(bit0) ^ bit1;
 }
 
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SurfaceTransformFlagsKHR
-operator~(SurfaceTransformFlagBitsKHR bits) VULKAN_HPP_NOEXCEPT {
-  return ~(SurfaceTransformFlagsKHR(bits));
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ImageConstraintsInfoFlagsFUCHSIAX
+operator~(ImageConstraintsInfoFlagBitsFUCHSIAX bits) VULKAN_HPP_NOEXCEPT {
+  return ~(ImageConstraintsInfoFlagsFUCHSIAX(bits));
 }
 
-VULKAN_HPP_INLINE std::string to_string(SurfaceTransformFlagsKHR value) {
-
+VULKAN_HPP_INLINE std::string
+to_string(ImageConstraintsInfoFlagsFUCHSIAX value) {
   if (!value)
     return "{}";
   std::string result;
 
-  if (value & SurfaceTransformFlagBitsKHR::eIdentity)
-    result += "Identity | ";
-  if (value & SurfaceTransformFlagBitsKHR::eRotate90)
-    result += "Rotate90 | ";
-  if (value & SurfaceTransformFlagBitsKHR::eRotate180)
-    result += "Rotate180 | ";
-  if (value & SurfaceTransformFlagBitsKHR::eRotate270)
-    result += "Rotate270 | ";
-  if (value & SurfaceTransformFlagBitsKHR::eHorizontalMirror)
-    result += "HorizontalMirror | ";
-  if (value & SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate90)
-    result += "HorizontalMirrorRotate90 | ";
-  if (value & SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate180)
-    result += "HorizontalMirrorRotate180 | ";
-  if (value & SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate270)
-    result += "HorizontalMirrorRotate270 | ";
-  if (value & SurfaceTransformFlagBitsKHR::eInherit)
-    result += "Inherit | ";
+  if (value & ImageConstraintsInfoFlagBitsFUCHSIAX::
+                  eVkImageConstraintsInfoCpuReadRarelyFuchsiax)
+    result += "VkImageConstraintsInfoCpuReadRarelyFuchsiax | ";
+  if (value & ImageConstraintsInfoFlagBitsFUCHSIAX::
+                  eVkImageConstraintsInfoCpuReadOftenFuchsiax)
+    result += "VkImageConstraintsInfoCpuReadOftenFuchsiax | ";
+  if (value & ImageConstraintsInfoFlagBitsFUCHSIAX::
+                  eVkImageConstraintsInfoCpuWriteRarelyFuchsiax)
+    result += "VkImageConstraintsInfoCpuWriteRarelyFuchsiax | ";
+  if (value & ImageConstraintsInfoFlagBitsFUCHSIAX::
+                  eVkImageConstraintsInfoCpuWriteOftenFuchsiax)
+    result += "VkImageConstraintsInfoCpuWriteOftenFuchsiax | ";
+  if (value & ImageConstraintsInfoFlagBitsFUCHSIAX::
+                  eVkImageConstraintsInfoProtectedOptionalFuchsiax)
+    result += "VkImageConstraintsInfoProtectedOptionalFuchsiax | ";
   return "{ " + result.substr(0, result.size() - 3) + " }";
 }
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
 
-using SwapchainCreateFlagsKHR = Flags<SwapchainCreateFlagBitsKHR>;
+#if defined(VK_USE_PLATFORM_SCREEN_QNX)
 
-template <> struct FlagTraits<SwapchainCreateFlagBitsKHR> {
+//=== VK_QNX_screen_surface ===
+
+enum class ScreenSurfaceCreateFlagBitsQNX : VkFlags {};
+
+VULKAN_HPP_INLINE std::string to_string(ScreenSurfaceCreateFlagBitsQNX) {
+  return "(void)";
+}
+
+using ScreenSurfaceCreateFlagsQNX = Flags<ScreenSurfaceCreateFlagBitsQNX>;
+
+VULKAN_HPP_INLINE std::string to_string(ScreenSurfaceCreateFlagsQNX) {
+  return "{}";
+}
+#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
+
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+
+//=== VK_FUCHSIA_buffer_collection ===
+
+using ImageFormatConstraintsFlagsFUCHSIA =
+    Flags<ImageFormatConstraintsFlagBitsFUCHSIA>;
+
+VULKAN_HPP_INLINE std::string to_string(ImageFormatConstraintsFlagsFUCHSIA) {
+  return "{}";
+}
+
+using ImageConstraintsInfoFlagsFUCHSIA =
+    Flags<ImageConstraintsInfoFlagBitsFUCHSIA>;
+
+template <> struct FlagTraits<ImageConstraintsInfoFlagBitsFUCHSIA> {
   enum : VkFlags {
-    allFlags = VkFlags(SwapchainCreateFlagBitsKHR::eSplitInstanceBindRegions) |
-               VkFlags(SwapchainCreateFlagBitsKHR::eProtected) |
-               VkFlags(SwapchainCreateFlagBitsKHR::eMutableFormat)
+    allFlags = VkFlags(ImageConstraintsInfoFlagBitsFUCHSIA::eCpuReadRarely) |
+               VkFlags(ImageConstraintsInfoFlagBitsFUCHSIA::eCpuReadOften) |
+               VkFlags(ImageConstraintsInfoFlagBitsFUCHSIA::eCpuWriteRarely) |
+               VkFlags(ImageConstraintsInfoFlagBitsFUCHSIA::eCpuWriteOften) |
+               VkFlags(ImageConstraintsInfoFlagBitsFUCHSIA::eProtectedOptional)
   };
 };
 
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SwapchainCreateFlagsKHR
-operator|(SwapchainCreateFlagBitsKHR bit0,
-          SwapchainCreateFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
-  return SwapchainCreateFlagsKHR(bit0) | bit1;
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ImageConstraintsInfoFlagsFUCHSIA
+operator|(ImageConstraintsInfoFlagBitsFUCHSIA bit0,
+          ImageConstraintsInfoFlagBitsFUCHSIA bit1) VULKAN_HPP_NOEXCEPT {
+  return ImageConstraintsInfoFlagsFUCHSIA(bit0) | bit1;
 }
 
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SwapchainCreateFlagsKHR
-operator&(SwapchainCreateFlagBitsKHR bit0,
-          SwapchainCreateFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
-  return SwapchainCreateFlagsKHR(bit0) & bit1;
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ImageConstraintsInfoFlagsFUCHSIA
+operator&(ImageConstraintsInfoFlagBitsFUCHSIA bit0,
+          ImageConstraintsInfoFlagBitsFUCHSIA bit1) VULKAN_HPP_NOEXCEPT {
+  return ImageConstraintsInfoFlagsFUCHSIA(bit0) & bit1;
 }
 
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SwapchainCreateFlagsKHR
-operator^(SwapchainCreateFlagBitsKHR bit0,
-          SwapchainCreateFlagBitsKHR bit1) VULKAN_HPP_NOEXCEPT {
-  return SwapchainCreateFlagsKHR(bit0) ^ bit1;
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ImageConstraintsInfoFlagsFUCHSIA
+operator^(ImageConstraintsInfoFlagBitsFUCHSIA bit0,
+          ImageConstraintsInfoFlagBitsFUCHSIA bit1) VULKAN_HPP_NOEXCEPT {
+  return ImageConstraintsInfoFlagsFUCHSIA(bit0) ^ bit1;
 }
 
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SwapchainCreateFlagsKHR
-operator~(SwapchainCreateFlagBitsKHR bits) VULKAN_HPP_NOEXCEPT {
-  return ~(SwapchainCreateFlagsKHR(bits));
+VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ImageConstraintsInfoFlagsFUCHSIA
+operator~(ImageConstraintsInfoFlagBitsFUCHSIA bits) VULKAN_HPP_NOEXCEPT {
+  return ~(ImageConstraintsInfoFlagsFUCHSIA(bits));
 }
 
-VULKAN_HPP_INLINE std::string to_string(SwapchainCreateFlagsKHR value) {
-
+VULKAN_HPP_INLINE std::string
+to_string(ImageConstraintsInfoFlagsFUCHSIA value) {
   if (!value)
     return "{}";
   std::string result;
 
-  if (value & SwapchainCreateFlagBitsKHR::eSplitInstanceBindRegions)
-    result += "SplitInstanceBindRegions | ";
-  if (value & SwapchainCreateFlagBitsKHR::eProtected)
-    result += "Protected | ";
-  if (value & SwapchainCreateFlagBitsKHR::eMutableFormat)
-    result += "MutableFormat | ";
+  if (value & ImageConstraintsInfoFlagBitsFUCHSIA::eCpuReadRarely)
+    result += "CpuReadRarely | ";
+  if (value & ImageConstraintsInfoFlagBitsFUCHSIA::eCpuReadOften)
+    result += "CpuReadOften | ";
+  if (value & ImageConstraintsInfoFlagBitsFUCHSIA::eCpuWriteRarely)
+    result += "CpuWriteRarely | ";
+  if (value & ImageConstraintsInfoFlagBitsFUCHSIA::eCpuWriteOften)
+    result += "CpuWriteOften | ";
+  if (value & ImageConstraintsInfoFlagBitsFUCHSIA::eProtectedOptional)
+    result += "ProtectedOptional | ";
   return "{ " + result.substr(0, result.size() - 3) + " }";
 }
-
-using ToolPurposeFlagsEXT = Flags<ToolPurposeFlagBitsEXT>;
-
-template <> struct FlagTraits<ToolPurposeFlagBitsEXT> {
-  enum : VkFlags {
-    allFlags = VkFlags(ToolPurposeFlagBitsEXT::eValidation) |
-               VkFlags(ToolPurposeFlagBitsEXT::eProfiling) |
-               VkFlags(ToolPurposeFlagBitsEXT::eTracing) |
-               VkFlags(ToolPurposeFlagBitsEXT::eAdditionalFeatures) |
-               VkFlags(ToolPurposeFlagBitsEXT::eModifyingFeatures) |
-               VkFlags(ToolPurposeFlagBitsEXT::eDebugReporting) |
-               VkFlags(ToolPurposeFlagBitsEXT::eDebugMarkers)
-  };
-};
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ToolPurposeFlagsEXT
-operator|(ToolPurposeFlagBitsEXT bit0,
-          ToolPurposeFlagBitsEXT bit1) VULKAN_HPP_NOEXCEPT {
-  return ToolPurposeFlagsEXT(bit0) | bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ToolPurposeFlagsEXT
-operator&(ToolPurposeFlagBitsEXT bit0,
-          ToolPurposeFlagBitsEXT bit1) VULKAN_HPP_NOEXCEPT {
-  return ToolPurposeFlagsEXT(bit0) & bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ToolPurposeFlagsEXT
-operator^(ToolPurposeFlagBitsEXT bit0,
-          ToolPurposeFlagBitsEXT bit1) VULKAN_HPP_NOEXCEPT {
-  return ToolPurposeFlagsEXT(bit0) ^ bit1;
-}
-
-VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ToolPurposeFlagsEXT
-operator~(ToolPurposeFlagBitsEXT bits) VULKAN_HPP_NOEXCEPT {
-  return ~(ToolPurposeFlagsEXT(bits));
-}
-
-VULKAN_HPP_INLINE std::string to_string(ToolPurposeFlagsEXT value) {
-
-  if (!value)
-    return "{}";
-  std::string result;
-
-  if (value & ToolPurposeFlagBitsEXT::eValidation)
-    result += "Validation | ";
-  if (value & ToolPurposeFlagBitsEXT::eProfiling)
-    result += "Profiling | ";
-  if (value & ToolPurposeFlagBitsEXT::eTracing)
-    result += "Tracing | ";
-  if (value & ToolPurposeFlagBitsEXT::eAdditionalFeatures)
-    result += "AdditionalFeatures | ";
-  if (value & ToolPurposeFlagBitsEXT::eModifyingFeatures)
-    result += "ModifyingFeatures | ";
-  if (value & ToolPurposeFlagBitsEXT::eDebugReporting)
-    result += "DebugReporting | ";
-  if (value & ToolPurposeFlagBitsEXT::eDebugMarkers)
-    result += "DebugMarkers | ";
-  return "{ " + result.substr(0, result.size() - 3) + " }";
-}
-
-enum class ValidationCacheCreateFlagBitsEXT : VkFlags {};
-
-VULKAN_HPP_INLINE std::string to_string(ValidationCacheCreateFlagBitsEXT) {
-  return "(void)";
-}
-
-using ValidationCacheCreateFlagsEXT = Flags<ValidationCacheCreateFlagBitsEXT>;
-
-VULKAN_HPP_INLINE std::string to_string(ValidationCacheCreateFlagsEXT) {
-
-  return "{}";
-}
-
-#if defined(VK_USE_PLATFORM_VI_NN)
-enum class ViSurfaceCreateFlagBitsNN : VkFlags {};
-
-VULKAN_HPP_INLINE std::string to_string(ViSurfaceCreateFlagBitsNN) {
-  return "(void)";
-}
-
-using ViSurfaceCreateFlagsNN = Flags<ViSurfaceCreateFlagBitsNN>;
-
-VULKAN_HPP_INLINE std::string to_string(ViSurfaceCreateFlagsNN) { return "{}"; }
-#endif /*VK_USE_PLATFORM_VI_NN*/
-
-#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
-enum class WaylandSurfaceCreateFlagBitsKHR : VkFlags {};
-
-VULKAN_HPP_INLINE std::string to_string(WaylandSurfaceCreateFlagBitsKHR) {
-  return "(void)";
-}
-
-using WaylandSurfaceCreateFlagsKHR = Flags<WaylandSurfaceCreateFlagBitsKHR>;
-
-VULKAN_HPP_INLINE std::string to_string(WaylandSurfaceCreateFlagsKHR) {
-
-  return "{}";
-}
-#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
-
-#if defined(VK_USE_PLATFORM_WIN32_KHR)
-enum class Win32SurfaceCreateFlagBitsKHR : VkFlags {};
-
-VULKAN_HPP_INLINE std::string to_string(Win32SurfaceCreateFlagBitsKHR) {
-  return "(void)";
-}
-
-using Win32SurfaceCreateFlagsKHR = Flags<Win32SurfaceCreateFlagBitsKHR>;
-
-VULKAN_HPP_INLINE std::string to_string(Win32SurfaceCreateFlagsKHR) {
-
-  return "{}";
-}
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#if defined(VK_USE_PLATFORM_XCB_KHR)
-enum class XcbSurfaceCreateFlagBitsKHR : VkFlags {};
-
-VULKAN_HPP_INLINE std::string to_string(XcbSurfaceCreateFlagBitsKHR) {
-  return "(void)";
-}
-
-using XcbSurfaceCreateFlagsKHR = Flags<XcbSurfaceCreateFlagBitsKHR>;
-
-VULKAN_HPP_INLINE std::string to_string(XcbSurfaceCreateFlagsKHR) {
-
-  return "{}";
-}
-#endif /*VK_USE_PLATFORM_XCB_KHR*/
-
-#if defined(VK_USE_PLATFORM_XLIB_KHR)
-enum class XlibSurfaceCreateFlagBitsKHR : VkFlags {};
-
-VULKAN_HPP_INLINE std::string to_string(XlibSurfaceCreateFlagBitsKHR) {
-  return "(void)";
-}
-
-using XlibSurfaceCreateFlagsKHR = Flags<XlibSurfaceCreateFlagBitsKHR>;
-
-VULKAN_HPP_INLINE std::string to_string(XlibSurfaceCreateFlagsKHR) {
-
-  return "{}";
-}
-#endif /*VK_USE_PLATFORM_XLIB_KHR*/
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
 } // namespace VULKAN_HPP_NAMESPACE
 
 #ifndef VULKAN_HPP_NO_EXCEPTIONS
@@ -20194,13 +21160,13 @@
         pGeometries(geometries_.data()), ppGeometries(pGeometries_.data()),
         scratchData(scratchData_) {
 #ifdef VULKAN_HPP_NO_EXCEPTIONS
-    VULKAN_HPP_ASSERT((!geometries_.empty() + !pGeometries_.empty()) == 1);
+    VULKAN_HPP_ASSERT((!geometries_.empty() + !pGeometries_.empty()) <= 1);
 #else
-    if ((!geometries_.empty() + !pGeometries_.empty()) != 1) {
+    if (1 < (!geometries_.empty() + !pGeometries_.empty())) {
       throw LogicError(VULKAN_HPP_NAMESPACE_STRING
                        "::AccelerationStructureBuildGeometryInfoKHR::"
-                       "AccelerationStructureBuildGeometryInfoKHR: ( "
-                       "!geometries_.empty() + !pGeometries_.empty() ) != 1");
+                       "AccelerationStructureBuildGeometryInfoKHR: 1 < ( "
+                       "!geometries_.empty() + !pGeometries_.empty() )");
     }
 #endif /*VULKAN_HPP_NO_EXCEPTIONS*/
   }
@@ -27204,6 +28170,199 @@
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 
 #if defined(VK_USE_PLATFORM_FUCHSIA)
+class BufferCollectionFUCHSIAX {
+public:
+  using CType = VkBufferCollectionFUCHSIAX;
+
+  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType
+      objectType = VULKAN_HPP_NAMESPACE::ObjectType::eBufferCollectionFuchsiax;
+  static VULKAN_HPP_CONST_OR_CONSTEXPR
+      VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
+          VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
+
+public:
+  VULKAN_HPP_CONSTEXPR BufferCollectionFUCHSIAX() = default;
+  VULKAN_HPP_CONSTEXPR
+  BufferCollectionFUCHSIAX(std::nullptr_t) VULKAN_HPP_NOEXCEPT {}
+  VULKAN_HPP_TYPESAFE_EXPLICIT BufferCollectionFUCHSIAX(
+      VkBufferCollectionFUCHSIAX bufferCollectionFUCHSIAX) VULKAN_HPP_NOEXCEPT
+      : m_bufferCollectionFUCHSIAX(bufferCollectionFUCHSIAX) {}
+
+#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
+  BufferCollectionFUCHSIAX &operator=(
+      VkBufferCollectionFUCHSIAX bufferCollectionFUCHSIAX) VULKAN_HPP_NOEXCEPT {
+    m_bufferCollectionFUCHSIAX = bufferCollectionFUCHSIAX;
+    return *this;
+  }
+#endif
+
+  BufferCollectionFUCHSIAX &operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT {
+    m_bufferCollectionFUCHSIAX = {};
+    return *this;
+  }
+
+#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
+  auto operator<=>(BufferCollectionFUCHSIAX const &) const = default;
+#else
+  bool
+  operator==(BufferCollectionFUCHSIAX const &rhs) const VULKAN_HPP_NOEXCEPT {
+    return m_bufferCollectionFUCHSIAX == rhs.m_bufferCollectionFUCHSIAX;
+  }
+
+  bool
+  operator!=(BufferCollectionFUCHSIAX const &rhs) const VULKAN_HPP_NOEXCEPT {
+    return m_bufferCollectionFUCHSIAX != rhs.m_bufferCollectionFUCHSIAX;
+  }
+
+  bool
+  operator<(BufferCollectionFUCHSIAX const &rhs) const VULKAN_HPP_NOEXCEPT {
+    return m_bufferCollectionFUCHSIAX < rhs.m_bufferCollectionFUCHSIAX;
+  }
+#endif
+
+  VULKAN_HPP_TYPESAFE_EXPLICIT
+  operator VkBufferCollectionFUCHSIAX() const VULKAN_HPP_NOEXCEPT {
+    return m_bufferCollectionFUCHSIAX;
+  }
+
+  explicit operator bool() const VULKAN_HPP_NOEXCEPT {
+    return m_bufferCollectionFUCHSIAX != VK_NULL_HANDLE;
+  }
+
+  bool operator!() const VULKAN_HPP_NOEXCEPT {
+    return m_bufferCollectionFUCHSIAX == VK_NULL_HANDLE;
+  }
+
+private:
+  VkBufferCollectionFUCHSIAX m_bufferCollectionFUCHSIAX = {};
+};
+static_assert(sizeof(VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIAX) ==
+                  sizeof(VkBufferCollectionFUCHSIAX),
+              "handle and wrapper have different size!");
+
+template <>
+struct VULKAN_HPP_DEPRECATED(
+    "vk::cpp_type is deprecated. Use vk::CppType instead.")
+    cpp_type<ObjectType::eBufferCollectionFuchsiax> {
+  using type = VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIAX;
+};
+
+template <>
+struct CppType<VULKAN_HPP_NAMESPACE::ObjectType,
+               VULKAN_HPP_NAMESPACE::ObjectType::eBufferCollectionFuchsiax> {
+  using Type = VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIAX;
+};
+
+template <>
+struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIAX> {
+  static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
+};
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+struct BufferCollectionBufferCreateInfoFUCHSIAX {
+  static const bool allowDuplicate = false;
+  static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType =
+      StructureType::eBufferCollectionBufferCreateInfoFuchsiax;
+
+#if !defined(VULKAN_HPP_NO_STRUCT_CONSTRUCTORS)
+  VULKAN_HPP_CONSTEXPR BufferCollectionBufferCreateInfoFUCHSIAX(
+      VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIAX collection_ = {},
+      uint32_t index_ = {}) VULKAN_HPP_NOEXCEPT : collection(collection_),
+                                                  index(index_) {}
+
+  VULKAN_HPP_CONSTEXPR BufferCollectionBufferCreateInfoFUCHSIAX(
+      BufferCollectionBufferCreateInfoFUCHSIAX const &rhs)
+      VULKAN_HPP_NOEXCEPT = default;
+
+  BufferCollectionBufferCreateInfoFUCHSIAX(
+      VkBufferCollectionBufferCreateInfoFUCHSIAX const &rhs) VULKAN_HPP_NOEXCEPT
+      : BufferCollectionBufferCreateInfoFUCHSIAX(
+            *reinterpret_cast<BufferCollectionBufferCreateInfoFUCHSIAX const *>(
+                &rhs)) {}
+#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+  VULKAN_HPP_CONSTEXPR_14 BufferCollectionBufferCreateInfoFUCHSIAX &
+  operator=(BufferCollectionBufferCreateInfoFUCHSIAX const &rhs)
+      VULKAN_HPP_NOEXCEPT = default;
+
+  BufferCollectionBufferCreateInfoFUCHSIAX &
+  operator=(VkBufferCollectionBufferCreateInfoFUCHSIAX const &rhs)
+      VULKAN_HPP_NOEXCEPT {
+    *this = *reinterpret_cast<
+        VULKAN_HPP_NAMESPACE::BufferCollectionBufferCreateInfoFUCHSIAX const *>(
+        &rhs);
+    return *this;
+  }
+
+  BufferCollectionBufferCreateInfoFUCHSIAX &
+  setPNext(const void *pNext_) VULKAN_HPP_NOEXCEPT {
+    pNext = pNext_;
+    return *this;
+  }
+
+  BufferCollectionBufferCreateInfoFUCHSIAX &
+  setCollection(VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIAX collection_)
+      VULKAN_HPP_NOEXCEPT {
+    collection = collection_;
+    return *this;
+  }
+
+  BufferCollectionBufferCreateInfoFUCHSIAX &
+  setIndex(uint32_t index_) VULKAN_HPP_NOEXCEPT {
+    index = index_;
+    return *this;
+  }
+
+  operator VkBufferCollectionBufferCreateInfoFUCHSIAX const &() const
+      VULKAN_HPP_NOEXCEPT {
+    return *reinterpret_cast<
+        const VkBufferCollectionBufferCreateInfoFUCHSIAX *>(this);
+  }
+
+  operator VkBufferCollectionBufferCreateInfoFUCHSIAX &() VULKAN_HPP_NOEXCEPT {
+    return *reinterpret_cast<VkBufferCollectionBufferCreateInfoFUCHSIAX *>(
+        this);
+  }
+
+#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
+  auto
+  operator<=>(BufferCollectionBufferCreateInfoFUCHSIAX const &) const = default;
+#else
+  bool operator==(BufferCollectionBufferCreateInfoFUCHSIAX const &rhs) const
+      VULKAN_HPP_NOEXCEPT {
+    return (sType == rhs.sType) && (pNext == rhs.pNext) &&
+           (collection == rhs.collection) && (index == rhs.index);
+  }
+
+  bool operator!=(BufferCollectionBufferCreateInfoFUCHSIAX const &rhs) const
+      VULKAN_HPP_NOEXCEPT {
+    return !operator==(rhs);
+  }
+#endif
+
+public:
+  VULKAN_HPP_NAMESPACE::StructureType sType =
+      StructureType::eBufferCollectionBufferCreateInfoFuchsiax;
+  const void *pNext = {};
+  VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIAX collection = {};
+  uint32_t index = {};
+};
+static_assert(sizeof(BufferCollectionBufferCreateInfoFUCHSIAX) ==
+                  sizeof(VkBufferCollectionBufferCreateInfoFUCHSIAX),
+              "struct and wrapper have different size!");
+static_assert(
+    std::is_standard_layout<BufferCollectionBufferCreateInfoFUCHSIAX>::value,
+    "struct wrapper is not a standard layout!");
+
+template <>
+struct CppType<StructureType,
+               StructureType::eBufferCollectionBufferCreateInfoFuchsiax> {
+  using Type = BufferCollectionBufferCreateInfoFUCHSIAX;
+};
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+
+#if defined(VK_USE_PLATFORM_FUCHSIA)
 struct BufferCollectionCreateInfoFUCHSIA {
   static const bool allowDuplicate = false;
   static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType =
@@ -27293,6 +28452,97 @@
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 
 #if defined(VK_USE_PLATFORM_FUCHSIA)
+struct BufferCollectionCreateInfoFUCHSIAX {
+  static const bool allowDuplicate = false;
+  static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType =
+      StructureType::eBufferCollectionCreateInfoFuchsiax;
+
+#if !defined(VULKAN_HPP_NO_STRUCT_CONSTRUCTORS)
+  VULKAN_HPP_CONSTEXPR BufferCollectionCreateInfoFUCHSIAX(
+      zx_handle_t collectionToken_ = {}) VULKAN_HPP_NOEXCEPT
+      : collectionToken(collectionToken_) {}
+
+  VULKAN_HPP_CONSTEXPR BufferCollectionCreateInfoFUCHSIAX(
+      BufferCollectionCreateInfoFUCHSIAX const &rhs)
+      VULKAN_HPP_NOEXCEPT = default;
+
+  BufferCollectionCreateInfoFUCHSIAX(
+      VkBufferCollectionCreateInfoFUCHSIAX const &rhs) VULKAN_HPP_NOEXCEPT
+      : BufferCollectionCreateInfoFUCHSIAX(
+            *reinterpret_cast<BufferCollectionCreateInfoFUCHSIAX const *>(
+                &rhs)) {}
+#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+  VULKAN_HPP_CONSTEXPR_14 BufferCollectionCreateInfoFUCHSIAX &
+  operator=(BufferCollectionCreateInfoFUCHSIAX const &rhs)
+      VULKAN_HPP_NOEXCEPT = default;
+
+  BufferCollectionCreateInfoFUCHSIAX &operator=(
+      VkBufferCollectionCreateInfoFUCHSIAX const &rhs) VULKAN_HPP_NOEXCEPT {
+    *this = *reinterpret_cast<
+        VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIAX const *>(&rhs);
+    return *this;
+  }
+
+  BufferCollectionCreateInfoFUCHSIAX &
+  setPNext(const void *pNext_) VULKAN_HPP_NOEXCEPT {
+    pNext = pNext_;
+    return *this;
+  }
+
+  BufferCollectionCreateInfoFUCHSIAX &
+  setCollectionToken(zx_handle_t collectionToken_) VULKAN_HPP_NOEXCEPT {
+    collectionToken = collectionToken_;
+    return *this;
+  }
+
+  operator VkBufferCollectionCreateInfoFUCHSIAX const &() const
+      VULKAN_HPP_NOEXCEPT {
+    return *reinterpret_cast<const VkBufferCollectionCreateInfoFUCHSIAX *>(
+        this);
+  }
+
+  operator VkBufferCollectionCreateInfoFUCHSIAX &() VULKAN_HPP_NOEXCEPT {
+    return *reinterpret_cast<VkBufferCollectionCreateInfoFUCHSIAX *>(this);
+  }
+
+#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
+  auto operator<=>(BufferCollectionCreateInfoFUCHSIAX const &) const = default;
+#else
+  bool operator==(BufferCollectionCreateInfoFUCHSIAX const &rhs) const
+      VULKAN_HPP_NOEXCEPT {
+    return (sType == rhs.sType) && (pNext == rhs.pNext) &&
+           (memcmp(&collectionToken, &rhs.collectionToken,
+                   sizeof(zx_handle_t)) == 0);
+  }
+
+  bool operator!=(BufferCollectionCreateInfoFUCHSIAX const &rhs) const
+      VULKAN_HPP_NOEXCEPT {
+    return !operator==(rhs);
+  }
+#endif
+
+public:
+  VULKAN_HPP_NAMESPACE::StructureType sType =
+      StructureType::eBufferCollectionCreateInfoFuchsiax;
+  const void *pNext = {};
+  zx_handle_t collectionToken = {};
+};
+static_assert(sizeof(BufferCollectionCreateInfoFUCHSIAX) ==
+                  sizeof(VkBufferCollectionCreateInfoFUCHSIAX),
+              "struct and wrapper have different size!");
+static_assert(
+    std::is_standard_layout<BufferCollectionCreateInfoFUCHSIAX>::value,
+    "struct wrapper is not a standard layout!");
+
+template <>
+struct CppType<StructureType,
+               StructureType::eBufferCollectionCreateInfoFuchsiax> {
+  using Type = BufferCollectionCreateInfoFUCHSIAX;
+};
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+
+#if defined(VK_USE_PLATFORM_FUCHSIA)
 struct BufferCollectionImageCreateInfoFUCHSIA {
   static const bool allowDuplicate = false;
   static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType =
@@ -27394,6 +28644,108 @@
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 
 #if defined(VK_USE_PLATFORM_FUCHSIA)
+struct BufferCollectionImageCreateInfoFUCHSIAX {
+  static const bool allowDuplicate = false;
+  static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType =
+      StructureType::eBufferCollectionImageCreateInfoFuchsiax;
+
+#if !defined(VULKAN_HPP_NO_STRUCT_CONSTRUCTORS)
+  VULKAN_HPP_CONSTEXPR BufferCollectionImageCreateInfoFUCHSIAX(
+      VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIAX collection_ = {},
+      uint32_t index_ = {}) VULKAN_HPP_NOEXCEPT : collection(collection_),
+                                                  index(index_) {}
+
+  VULKAN_HPP_CONSTEXPR BufferCollectionImageCreateInfoFUCHSIAX(
+      BufferCollectionImageCreateInfoFUCHSIAX const &rhs)
+      VULKAN_HPP_NOEXCEPT = default;
+
+  BufferCollectionImageCreateInfoFUCHSIAX(
+      VkBufferCollectionImageCreateInfoFUCHSIAX const &rhs) VULKAN_HPP_NOEXCEPT
+      : BufferCollectionImageCreateInfoFUCHSIAX(
+            *reinterpret_cast<BufferCollectionImageCreateInfoFUCHSIAX const *>(
+                &rhs)) {}
+#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+  VULKAN_HPP_CONSTEXPR_14 BufferCollectionImageCreateInfoFUCHSIAX &
+  operator=(BufferCollectionImageCreateInfoFUCHSIAX const &rhs)
+      VULKAN_HPP_NOEXCEPT = default;
+
+  BufferCollectionImageCreateInfoFUCHSIAX &
+  operator=(VkBufferCollectionImageCreateInfoFUCHSIAX const &rhs)
+      VULKAN_HPP_NOEXCEPT {
+    *this = *reinterpret_cast<
+        VULKAN_HPP_NAMESPACE::BufferCollectionImageCreateInfoFUCHSIAX const *>(
+        &rhs);
+    return *this;
+  }
+
+  BufferCollectionImageCreateInfoFUCHSIAX &
+  setPNext(const void *pNext_) VULKAN_HPP_NOEXCEPT {
+    pNext = pNext_;
+    return *this;
+  }
+
+  BufferCollectionImageCreateInfoFUCHSIAX &
+  setCollection(VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIAX collection_)
+      VULKAN_HPP_NOEXCEPT {
+    collection = collection_;
+    return *this;
+  }
+
+  BufferCollectionImageCreateInfoFUCHSIAX &
+  setIndex(uint32_t index_) VULKAN_HPP_NOEXCEPT {
+    index = index_;
+    return *this;
+  }
+
+  operator VkBufferCollectionImageCreateInfoFUCHSIAX const &() const
+      VULKAN_HPP_NOEXCEPT {
+    return *reinterpret_cast<const VkBufferCollectionImageCreateInfoFUCHSIAX *>(
+        this);
+  }
+
+  operator VkBufferCollectionImageCreateInfoFUCHSIAX &() VULKAN_HPP_NOEXCEPT {
+    return *reinterpret_cast<VkBufferCollectionImageCreateInfoFUCHSIAX *>(this);
+  }
+
+#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
+  auto
+  operator<=>(BufferCollectionImageCreateInfoFUCHSIAX const &) const = default;
+#else
+  bool operator==(BufferCollectionImageCreateInfoFUCHSIAX const &rhs) const
+      VULKAN_HPP_NOEXCEPT {
+    return (sType == rhs.sType) && (pNext == rhs.pNext) &&
+           (collection == rhs.collection) && (index == rhs.index);
+  }
+
+  bool operator!=(BufferCollectionImageCreateInfoFUCHSIAX const &rhs) const
+      VULKAN_HPP_NOEXCEPT {
+    return !operator==(rhs);
+  }
+#endif
+
+public:
+  VULKAN_HPP_NAMESPACE::StructureType sType =
+      StructureType::eBufferCollectionImageCreateInfoFuchsiax;
+  const void *pNext = {};
+  VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIAX collection = {};
+  uint32_t index = {};
+};
+static_assert(sizeof(BufferCollectionImageCreateInfoFUCHSIAX) ==
+                  sizeof(VkBufferCollectionImageCreateInfoFUCHSIAX),
+              "struct and wrapper have different size!");
+static_assert(
+    std::is_standard_layout<BufferCollectionImageCreateInfoFUCHSIAX>::value,
+    "struct wrapper is not a standard layout!");
+
+template <>
+struct CppType<StructureType,
+               StructureType::eBufferCollectionImageCreateInfoFuchsiax> {
+  using Type = BufferCollectionImageCreateInfoFUCHSIAX;
+};
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+
+#if defined(VK_USE_PLATFORM_FUCHSIA)
 struct SysmemColorSpaceFUCHSIA {
   static const bool allowDuplicate = false;
   static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType =
@@ -27682,6 +29034,295 @@
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 
 #if defined(VK_USE_PLATFORM_FUCHSIA)
+struct SysmemColorSpaceFUCHSIAX {
+  static const bool allowDuplicate = false;
+  static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType =
+      StructureType::eSysmemColorSpaceFuchsiax;
+
+#if !defined(VULKAN_HPP_NO_STRUCT_CONSTRUCTORS)
+  VULKAN_HPP_CONSTEXPR
+  SysmemColorSpaceFUCHSIAX(uint32_t colorSpace_ = {}) VULKAN_HPP_NOEXCEPT
+      : colorSpace(colorSpace_) {}
+
+  VULKAN_HPP_CONSTEXPR SysmemColorSpaceFUCHSIAX(
+      SysmemColorSpaceFUCHSIAX const &rhs) VULKAN_HPP_NOEXCEPT = default;
+
+  SysmemColorSpaceFUCHSIAX(VkSysmemColorSpaceFUCHSIAX const &rhs)
+      VULKAN_HPP_NOEXCEPT
+      : SysmemColorSpaceFUCHSIAX(
+            *reinterpret_cast<SysmemColorSpaceFUCHSIAX const *>(&rhs)) {}
+#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+  VULKAN_HPP_CONSTEXPR_14 SysmemColorSpaceFUCHSIAX &
+  operator=(SysmemColorSpaceFUCHSIAX const &rhs) VULKAN_HPP_NOEXCEPT = default;
+
+  SysmemColorSpaceFUCHSIAX &
+  operator=(VkSysmemColorSpaceFUCHSIAX const &rhs) VULKAN_HPP_NOEXCEPT {
+    *this = *reinterpret_cast<
+        VULKAN_HPP_NAMESPACE::SysmemColorSpaceFUCHSIAX const *>(&rhs);
+    return *this;
+  }
+
+  SysmemColorSpaceFUCHSIAX &setPNext(const void *pNext_) VULKAN_HPP_NOEXCEPT {
+    pNext = pNext_;
+    return *this;
+  }
+
+  SysmemColorSpaceFUCHSIAX &
+  setColorSpace(uint32_t colorSpace_) VULKAN_HPP_NOEXCEPT {
+    colorSpace = colorSpace_;
+    return *this;
+  }
+
+  operator VkSysmemColorSpaceFUCHSIAX const &() const VULKAN_HPP_NOEXCEPT {
+    return *reinterpret_cast<const VkSysmemColorSpaceFUCHSIAX *>(this);
+  }
+
+  operator VkSysmemColorSpaceFUCHSIAX &() VULKAN_HPP_NOEXCEPT {
+    return *reinterpret_cast<VkSysmemColorSpaceFUCHSIAX *>(this);
+  }
+
+#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
+  auto operator<=>(SysmemColorSpaceFUCHSIAX const &) const = default;
+#else
+  bool
+  operator==(SysmemColorSpaceFUCHSIAX const &rhs) const VULKAN_HPP_NOEXCEPT {
+    return (sType == rhs.sType) && (pNext == rhs.pNext) &&
+           (colorSpace == rhs.colorSpace);
+  }
+
+  bool
+  operator!=(SysmemColorSpaceFUCHSIAX const &rhs) const VULKAN_HPP_NOEXCEPT {
+    return !operator==(rhs);
+  }
+#endif
+
+public:
+  VULKAN_HPP_NAMESPACE::StructureType sType =
+      StructureType::eSysmemColorSpaceFuchsiax;
+  const void *pNext = {};
+  uint32_t colorSpace = {};
+};
+static_assert(sizeof(SysmemColorSpaceFUCHSIAX) ==
+                  sizeof(VkSysmemColorSpaceFUCHSIAX),
+              "struct and wrapper have different size!");
+static_assert(std::is_standard_layout<SysmemColorSpaceFUCHSIAX>::value,
+              "struct wrapper is not a standard layout!");
+
+template <>
+struct CppType<StructureType, StructureType::eSysmemColorSpaceFuchsiax> {
+  using Type = SysmemColorSpaceFUCHSIAX;
+};
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+struct BufferCollectionProperties2FUCHSIAX {
+  static const bool allowDuplicate = false;
+  static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType =
+      StructureType::eBufferCollectionProperties2Fuchsiax;
+
+#if !defined(VULKAN_HPP_NO_STRUCT_CONSTRUCTORS)
+  VULKAN_HPP_CONSTEXPR BufferCollectionProperties2FUCHSIAX(
+      uint32_t memoryTypeBits_ = {}, uint32_t bufferCount_ = {},
+      uint32_t createInfoIndex_ = {}, uint64_t sysmemFormat_ = {},
+      VULKAN_HPP_NAMESPACE::FormatFeatureFlags formatFeatures_ = {},
+      VULKAN_HPP_NAMESPACE::SysmemColorSpaceFUCHSIAX colorSpace_ = {},
+      VULKAN_HPP_NAMESPACE::ComponentMapping samplerYcbcrConversionComponents_ =
+          {},
+      VULKAN_HPP_NAMESPACE::SamplerYcbcrModelConversion suggestedYcbcrModel_ =
+          VULKAN_HPP_NAMESPACE::SamplerYcbcrModelConversion::eRgbIdentity,
+      VULKAN_HPP_NAMESPACE::SamplerYcbcrRange suggestedYcbcrRange_ =
+          VULKAN_HPP_NAMESPACE::SamplerYcbcrRange::eItuFull,
+      VULKAN_HPP_NAMESPACE::ChromaLocation suggestedXChromaOffset_ =
+          VULKAN_HPP_NAMESPACE::ChromaLocation::eCositedEven,
+      VULKAN_HPP_NAMESPACE::ChromaLocation suggestedYChromaOffset_ =
+          VULKAN_HPP_NAMESPACE::ChromaLocation::eCositedEven)
+      VULKAN_HPP_NOEXCEPT
+      : memoryTypeBits(memoryTypeBits_),
+        bufferCount(bufferCount_),
+        createInfoIndex(createInfoIndex_),
+        sysmemFormat(sysmemFormat_),
+        formatFeatures(formatFeatures_),
+        colorSpace(colorSpace_),
+        samplerYcbcrConversionComponents(samplerYcbcrConversionComponents_),
+        suggestedYcbcrModel(suggestedYcbcrModel_),
+        suggestedYcbcrRange(suggestedYcbcrRange_),
+        suggestedXChromaOffset(suggestedXChromaOffset_),
+        suggestedYChromaOffset(suggestedYChromaOffset_) {}
+
+  VULKAN_HPP_CONSTEXPR BufferCollectionProperties2FUCHSIAX(
+      BufferCollectionProperties2FUCHSIAX const &rhs)
+      VULKAN_HPP_NOEXCEPT = default;
+
+  BufferCollectionProperties2FUCHSIAX(
+      VkBufferCollectionProperties2FUCHSIAX const &rhs) VULKAN_HPP_NOEXCEPT
+      : BufferCollectionProperties2FUCHSIAX(
+            *reinterpret_cast<BufferCollectionProperties2FUCHSIAX const *>(
+                &rhs)) {}
+#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+  VULKAN_HPP_CONSTEXPR_14 BufferCollectionProperties2FUCHSIAX &
+  operator=(BufferCollectionProperties2FUCHSIAX const &rhs)
+      VULKAN_HPP_NOEXCEPT = default;
+
+  BufferCollectionProperties2FUCHSIAX &operator=(
+      VkBufferCollectionProperties2FUCHSIAX const &rhs) VULKAN_HPP_NOEXCEPT {
+    *this = *reinterpret_cast<
+        VULKAN_HPP_NAMESPACE::BufferCollectionProperties2FUCHSIAX const *>(
+        &rhs);
+    return *this;
+  }
+
+  BufferCollectionProperties2FUCHSIAX &
+  setPNext(void *pNext_) VULKAN_HPP_NOEXCEPT {
+    pNext = pNext_;
+    return *this;
+  }
+
+  BufferCollectionProperties2FUCHSIAX &
+  setMemoryTypeBits(uint32_t memoryTypeBits_) VULKAN_HPP_NOEXCEPT {
+    memoryTypeBits = memoryTypeBits_;
+    return *this;
+  }
+
+  BufferCollectionProperties2FUCHSIAX &
+  setBufferCount(uint32_t bufferCount_) VULKAN_HPP_NOEXCEPT {
+    bufferCount = bufferCount_;
+    return *this;
+  }
+
+  BufferCollectionProperties2FUCHSIAX &
+  setCreateInfoIndex(uint32_t createInfoIndex_) VULKAN_HPP_NOEXCEPT {
+    createInfoIndex = createInfoIndex_;
+    return *this;
+  }
+
+  BufferCollectionProperties2FUCHSIAX &
+  setSysmemFormat(uint64_t sysmemFormat_) VULKAN_HPP_NOEXCEPT {
+    sysmemFormat = sysmemFormat_;
+    return *this;
+  }
+
+  BufferCollectionProperties2FUCHSIAX &
+  setFormatFeatures(VULKAN_HPP_NAMESPACE::FormatFeatureFlags formatFeatures_)
+      VULKAN_HPP_NOEXCEPT {
+    formatFeatures = formatFeatures_;
+    return *this;
+  }
+
+  BufferCollectionProperties2FUCHSIAX &setColorSpace(
+      VULKAN_HPP_NAMESPACE::SysmemColorSpaceFUCHSIAX const &colorSpace_)
+      VULKAN_HPP_NOEXCEPT {
+    colorSpace = colorSpace_;
+    return *this;
+  }
+
+  BufferCollectionProperties2FUCHSIAX &setSamplerYcbcrConversionComponents(
+      VULKAN_HPP_NAMESPACE::ComponentMapping const
+          &samplerYcbcrConversionComponents_) VULKAN_HPP_NOEXCEPT {
+    samplerYcbcrConversionComponents = samplerYcbcrConversionComponents_;
+    return *this;
+  }
+
+  BufferCollectionProperties2FUCHSIAX &setSuggestedYcbcrModel(
+      VULKAN_HPP_NAMESPACE::SamplerYcbcrModelConversion suggestedYcbcrModel_)
+      VULKAN_HPP_NOEXCEPT {
+    suggestedYcbcrModel = suggestedYcbcrModel_;
+    return *this;
+  }
+
+  BufferCollectionProperties2FUCHSIAX &setSuggestedYcbcrRange(
+      VULKAN_HPP_NAMESPACE::SamplerYcbcrRange suggestedYcbcrRange_)
+      VULKAN_HPP_NOEXCEPT {
+    suggestedYcbcrRange = suggestedYcbcrRange_;
+    return *this;
+  }
+
+  BufferCollectionProperties2FUCHSIAX &setSuggestedXChromaOffset(
+      VULKAN_HPP_NAMESPACE::ChromaLocation suggestedXChromaOffset_)
+      VULKAN_HPP_NOEXCEPT {
+    suggestedXChromaOffset = suggestedXChromaOffset_;
+    return *this;
+  }
+
+  BufferCollectionProperties2FUCHSIAX &setSuggestedYChromaOffset(
+      VULKAN_HPP_NAMESPACE::ChromaLocation suggestedYChromaOffset_)
+      VULKAN_HPP_NOEXCEPT {
+    suggestedYChromaOffset = suggestedYChromaOffset_;
+    return *this;
+  }
+
+  operator VkBufferCollectionProperties2FUCHSIAX const &() const
+      VULKAN_HPP_NOEXCEPT {
+    return *reinterpret_cast<const VkBufferCollectionProperties2FUCHSIAX *>(
+        this);
+  }
+
+  operator VkBufferCollectionProperties2FUCHSIAX &() VULKAN_HPP_NOEXCEPT {
+    return *reinterpret_cast<VkBufferCollectionProperties2FUCHSIAX *>(this);
+  }
+
+#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
+  auto operator<=>(BufferCollectionProperties2FUCHSIAX const &) const = default;
+#else
+  bool operator==(BufferCollectionProperties2FUCHSIAX const &rhs) const
+      VULKAN_HPP_NOEXCEPT {
+    return (sType == rhs.sType) && (pNext == rhs.pNext) &&
+           (memoryTypeBits == rhs.memoryTypeBits) &&
+           (bufferCount == rhs.bufferCount) &&
+           (createInfoIndex == rhs.createInfoIndex) &&
+           (sysmemFormat == rhs.sysmemFormat) &&
+           (formatFeatures == rhs.formatFeatures) &&
+           (colorSpace == rhs.colorSpace) &&
+           (samplerYcbcrConversionComponents ==
+            rhs.samplerYcbcrConversionComponents) &&
+           (suggestedYcbcrModel == rhs.suggestedYcbcrModel) &&
+           (suggestedYcbcrRange == rhs.suggestedYcbcrRange) &&
+           (suggestedXChromaOffset == rhs.suggestedXChromaOffset) &&
+           (suggestedYChromaOffset == rhs.suggestedYChromaOffset);
+  }
+
+  bool operator!=(BufferCollectionProperties2FUCHSIAX const &rhs) const
+      VULKAN_HPP_NOEXCEPT {
+    return !operator==(rhs);
+  }
+#endif
+
+public:
+  VULKAN_HPP_NAMESPACE::StructureType sType =
+      StructureType::eBufferCollectionProperties2Fuchsiax;
+  void *pNext = {};
+  uint32_t memoryTypeBits = {};
+  uint32_t bufferCount = {};
+  uint32_t createInfoIndex = {};
+  uint64_t sysmemFormat = {};
+  VULKAN_HPP_NAMESPACE::FormatFeatureFlags formatFeatures = {};
+  VULKAN_HPP_NAMESPACE::SysmemColorSpaceFUCHSIAX colorSpace = {};
+  VULKAN_HPP_NAMESPACE::ComponentMapping samplerYcbcrConversionComponents = {};
+  VULKAN_HPP_NAMESPACE::SamplerYcbcrModelConversion suggestedYcbcrModel =
+      VULKAN_HPP_NAMESPACE::SamplerYcbcrModelConversion::eRgbIdentity;
+  VULKAN_HPP_NAMESPACE::SamplerYcbcrRange suggestedYcbcrRange =
+      VULKAN_HPP_NAMESPACE::SamplerYcbcrRange::eItuFull;
+  VULKAN_HPP_NAMESPACE::ChromaLocation suggestedXChromaOffset =
+      VULKAN_HPP_NAMESPACE::ChromaLocation::eCositedEven;
+  VULKAN_HPP_NAMESPACE::ChromaLocation suggestedYChromaOffset =
+      VULKAN_HPP_NAMESPACE::ChromaLocation::eCositedEven;
+};
+static_assert(sizeof(BufferCollectionProperties2FUCHSIAX) ==
+                  sizeof(VkBufferCollectionProperties2FUCHSIAX),
+              "struct and wrapper have different size!");
+static_assert(
+    std::is_standard_layout<BufferCollectionProperties2FUCHSIAX>::value,
+    "struct wrapper is not a standard layout!");
+
+template <>
+struct CppType<StructureType,
+               StructureType::eBufferCollectionProperties2Fuchsiax> {
+  using Type = BufferCollectionProperties2FUCHSIAX;
+};
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+
+#if defined(VK_USE_PLATFORM_FUCHSIA)
 struct BufferCollectionPropertiesFUCHSIA {
   static const bool allowDuplicate = false;
   static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType =
@@ -27778,6 +29419,105 @@
 };
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+struct BufferCollectionPropertiesFUCHSIAX {
+  static const bool allowDuplicate = false;
+  static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType =
+      StructureType::eBufferCollectionPropertiesFuchsiax;
+
+#if !defined(VULKAN_HPP_NO_STRUCT_CONSTRUCTORS)
+  VULKAN_HPP_CONSTEXPR
+  BufferCollectionPropertiesFUCHSIAX(uint32_t memoryTypeBits_ = {},
+                                     uint32_t count_ = {}) VULKAN_HPP_NOEXCEPT
+      : memoryTypeBits(memoryTypeBits_),
+        count(count_) {}
+
+  VULKAN_HPP_CONSTEXPR BufferCollectionPropertiesFUCHSIAX(
+      BufferCollectionPropertiesFUCHSIAX const &rhs)
+      VULKAN_HPP_NOEXCEPT = default;
+
+  BufferCollectionPropertiesFUCHSIAX(
+      VkBufferCollectionPropertiesFUCHSIAX const &rhs) VULKAN_HPP_NOEXCEPT
+      : BufferCollectionPropertiesFUCHSIAX(
+            *reinterpret_cast<BufferCollectionPropertiesFUCHSIAX const *>(
+                &rhs)) {}
+#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+  VULKAN_HPP_CONSTEXPR_14 BufferCollectionPropertiesFUCHSIAX &
+  operator=(BufferCollectionPropertiesFUCHSIAX const &rhs)
+      VULKAN_HPP_NOEXCEPT = default;
+
+  BufferCollectionPropertiesFUCHSIAX &operator=(
+      VkBufferCollectionPropertiesFUCHSIAX const &rhs) VULKAN_HPP_NOEXCEPT {
+    *this = *reinterpret_cast<
+        VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIAX const *>(&rhs);
+    return *this;
+  }
+
+  BufferCollectionPropertiesFUCHSIAX &
+  setPNext(void *pNext_) VULKAN_HPP_NOEXCEPT {
+    pNext = pNext_;
+    return *this;
+  }
+
+  BufferCollectionPropertiesFUCHSIAX &
+  setMemoryTypeBits(uint32_t memoryTypeBits_) VULKAN_HPP_NOEXCEPT {
+    memoryTypeBits = memoryTypeBits_;
+    return *this;
+  }
+
+  BufferCollectionPropertiesFUCHSIAX &
+  setCount(uint32_t count_) VULKAN_HPP_NOEXCEPT {
+    count = count_;
+    return *this;
+  }
+
+  operator VkBufferCollectionPropertiesFUCHSIAX const &() const
+      VULKAN_HPP_NOEXCEPT {
+    return *reinterpret_cast<const VkBufferCollectionPropertiesFUCHSIAX *>(
+        this);
+  }
+
+  operator VkBufferCollectionPropertiesFUCHSIAX &() VULKAN_HPP_NOEXCEPT {
+    return *reinterpret_cast<VkBufferCollectionPropertiesFUCHSIAX *>(this);
+  }
+
+#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
+  auto operator<=>(BufferCollectionPropertiesFUCHSIAX const &) const = default;
+#else
+  bool operator==(BufferCollectionPropertiesFUCHSIAX const &rhs) const
+      VULKAN_HPP_NOEXCEPT {
+    return (sType == rhs.sType) && (pNext == rhs.pNext) &&
+           (memoryTypeBits == rhs.memoryTypeBits) && (count == rhs.count);
+  }
+
+  bool operator!=(BufferCollectionPropertiesFUCHSIAX const &rhs) const
+      VULKAN_HPP_NOEXCEPT {
+    return !operator==(rhs);
+  }
+#endif
+
+public:
+  VULKAN_HPP_NAMESPACE::StructureType sType =
+      StructureType::eBufferCollectionPropertiesFuchsiax;
+  void *pNext = {};
+  uint32_t memoryTypeBits = {};
+  uint32_t count = {};
+};
+static_assert(sizeof(BufferCollectionPropertiesFUCHSIAX) ==
+                  sizeof(VkBufferCollectionPropertiesFUCHSIAX),
+              "struct and wrapper have different size!");
+static_assert(
+    std::is_standard_layout<BufferCollectionPropertiesFUCHSIAX>::value,
+    "struct wrapper is not a standard layout!");
+
+template <>
+struct CppType<StructureType,
+               StructureType::eBufferCollectionPropertiesFuchsiax> {
+  using Type = BufferCollectionPropertiesFUCHSIAX;
+};
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+
 struct BufferCreateInfo {
   static const bool allowDuplicate = false;
   static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType =
@@ -28030,6 +29770,111 @@
 };
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+struct BufferConstraintsInfoFUCHSIAX {
+  static const bool allowDuplicate = false;
+  static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType =
+      StructureType::eBufferConstraintsInfoFuchsiax;
+
+#if !defined(VULKAN_HPP_NO_STRUCT_CONSTRUCTORS)
+  VULKAN_HPP_CONSTEXPR BufferConstraintsInfoFUCHSIAX(
+      const VULKAN_HPP_NAMESPACE::BufferCreateInfo *pBufferCreateInfo_ = {},
+      VULKAN_HPP_NAMESPACE::FormatFeatureFlags requiredFormatFeatures_ = {},
+      uint32_t minCount_ = {}) VULKAN_HPP_NOEXCEPT
+      : pBufferCreateInfo(pBufferCreateInfo_),
+        requiredFormatFeatures(requiredFormatFeatures_),
+        minCount(minCount_) {}
+
+  VULKAN_HPP_CONSTEXPR BufferConstraintsInfoFUCHSIAX(
+      BufferConstraintsInfoFUCHSIAX const &rhs) VULKAN_HPP_NOEXCEPT = default;
+
+  BufferConstraintsInfoFUCHSIAX(VkBufferConstraintsInfoFUCHSIAX const &rhs)
+      VULKAN_HPP_NOEXCEPT
+      : BufferConstraintsInfoFUCHSIAX(
+            *reinterpret_cast<BufferConstraintsInfoFUCHSIAX const *>(&rhs)) {}
+#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+  VULKAN_HPP_CONSTEXPR_14 BufferConstraintsInfoFUCHSIAX &operator=(
+      BufferConstraintsInfoFUCHSIAX const &rhs) VULKAN_HPP_NOEXCEPT = default;
+
+  BufferConstraintsInfoFUCHSIAX &
+  operator=(VkBufferConstraintsInfoFUCHSIAX const &rhs) VULKAN_HPP_NOEXCEPT {
+    *this = *reinterpret_cast<
+        VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIAX const *>(&rhs);
+    return *this;
+  }
+
+  BufferConstraintsInfoFUCHSIAX &
+  setPNext(const void *pNext_) VULKAN_HPP_NOEXCEPT {
+    pNext = pNext_;
+    return *this;
+  }
+
+  BufferConstraintsInfoFUCHSIAX &setPBufferCreateInfo(
+      const VULKAN_HPP_NAMESPACE::BufferCreateInfo *pBufferCreateInfo_)
+      VULKAN_HPP_NOEXCEPT {
+    pBufferCreateInfo = pBufferCreateInfo_;
+    return *this;
+  }
+
+  BufferConstraintsInfoFUCHSIAX &setRequiredFormatFeatures(
+      VULKAN_HPP_NAMESPACE::FormatFeatureFlags requiredFormatFeatures_)
+      VULKAN_HPP_NOEXCEPT {
+    requiredFormatFeatures = requiredFormatFeatures_;
+    return *this;
+  }
+
+  BufferConstraintsInfoFUCHSIAX &
+  setMinCount(uint32_t minCount_) VULKAN_HPP_NOEXCEPT {
+    minCount = minCount_;
+    return *this;
+  }
+
+  operator VkBufferConstraintsInfoFUCHSIAX const &() const VULKAN_HPP_NOEXCEPT {
+    return *reinterpret_cast<const VkBufferConstraintsInfoFUCHSIAX *>(this);
+  }
+
+  operator VkBufferConstraintsInfoFUCHSIAX &() VULKAN_HPP_NOEXCEPT {
+    return *reinterpret_cast<VkBufferConstraintsInfoFUCHSIAX *>(this);
+  }
+
+#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
+  auto operator<=>(BufferConstraintsInfoFUCHSIAX const &) const = default;
+#else
+  bool operator==(BufferConstraintsInfoFUCHSIAX const &rhs) const
+      VULKAN_HPP_NOEXCEPT {
+    return (sType == rhs.sType) && (pNext == rhs.pNext) &&
+           (pBufferCreateInfo == rhs.pBufferCreateInfo) &&
+           (requiredFormatFeatures == rhs.requiredFormatFeatures) &&
+           (minCount == rhs.minCount);
+  }
+
+  bool operator!=(BufferConstraintsInfoFUCHSIAX const &rhs) const
+      VULKAN_HPP_NOEXCEPT {
+    return !operator==(rhs);
+  }
+#endif
+
+public:
+  VULKAN_HPP_NAMESPACE::StructureType sType =
+      StructureType::eBufferConstraintsInfoFuchsiax;
+  const void *pNext = {};
+  const VULKAN_HPP_NAMESPACE::BufferCreateInfo *pBufferCreateInfo = {};
+  VULKAN_HPP_NAMESPACE::FormatFeatureFlags requiredFormatFeatures = {};
+  uint32_t minCount = {};
+};
+static_assert(sizeof(BufferConstraintsInfoFUCHSIAX) ==
+                  sizeof(VkBufferConstraintsInfoFUCHSIAX),
+              "struct and wrapper have different size!");
+static_assert(std::is_standard_layout<BufferConstraintsInfoFUCHSIAX>::value,
+              "struct wrapper is not a standard layout!");
+
+template <>
+struct CppType<StructureType, StructureType::eBufferConstraintsInfoFuchsiax> {
+  using Type = BufferConstraintsInfoFUCHSIAX;
+};
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+
 struct BufferCopy {
 
 #if !defined(VULKAN_HPP_NO_STRUCT_CONSTRUCTORS)
@@ -34449,14 +36294,14 @@
         pTexelBufferView(texelBufferView_.data()) {
 #ifdef VULKAN_HPP_NO_EXCEPTIONS
     VULKAN_HPP_ASSERT((!imageInfo_.empty() + !bufferInfo_.empty() +
-                       !texelBufferView_.empty()) == 1);
+                       !texelBufferView_.empty()) <= 1);
 #else
-    if ((!imageInfo_.empty() + !bufferInfo_.empty() +
-         !texelBufferView_.empty()) != 1) {
+    if (1 < (!imageInfo_.empty() + !bufferInfo_.empty() +
+             !texelBufferView_.empty())) {
       throw LogicError(
           VULKAN_HPP_NAMESPACE_STRING
-          "::WriteDescriptorSet::WriteDescriptorSet: ( !imageInfo_.empty() + "
-          "!bufferInfo_.empty() + !texelBufferView_.empty() ) != 1");
+          "::WriteDescriptorSet::WriteDescriptorSet: 1 < ( !imageInfo_.empty() "
+          "+ !bufferInfo_.empty() + !texelBufferView_.empty() )");
     }
 #endif /*VULKAN_HPP_NO_EXCEPTIONS*/
   }
@@ -56526,6 +58371,364 @@
 };
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+struct ImageFormatConstraintsInfoFUCHSIAX {
+  static const bool allowDuplicate = false;
+  static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType =
+      StructureType::eImageFormatConstraintsInfoFuchsiax;
+
+#if !defined(VULKAN_HPP_NO_STRUCT_CONSTRUCTORS)
+  VULKAN_HPP_CONSTEXPR ImageFormatConstraintsInfoFUCHSIAX(
+      VULKAN_HPP_NAMESPACE::FormatFeatureFlags requiredFormatFeatures_ = {},
+      VULKAN_HPP_NAMESPACE::ImageFormatConstraintsFlagsFUCHSIAX flags_ = {},
+      uint64_t sysmemFormat_ = {}, uint32_t colorSpaceCount_ = {},
+      const VULKAN_HPP_NAMESPACE::SysmemColorSpaceFUCHSIAX *pColorSpaces_ = {})
+      VULKAN_HPP_NOEXCEPT : requiredFormatFeatures(requiredFormatFeatures_),
+                            flags(flags_),
+                            sysmemFormat(sysmemFormat_),
+                            colorSpaceCount(colorSpaceCount_),
+                            pColorSpaces(pColorSpaces_) {}
+
+  VULKAN_HPP_CONSTEXPR ImageFormatConstraintsInfoFUCHSIAX(
+      ImageFormatConstraintsInfoFUCHSIAX const &rhs)
+      VULKAN_HPP_NOEXCEPT = default;
+
+  ImageFormatConstraintsInfoFUCHSIAX(
+      VkImageFormatConstraintsInfoFUCHSIAX const &rhs) VULKAN_HPP_NOEXCEPT
+      : ImageFormatConstraintsInfoFUCHSIAX(
+            *reinterpret_cast<ImageFormatConstraintsInfoFUCHSIAX const *>(
+                &rhs)) {}
+#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+  VULKAN_HPP_CONSTEXPR_14 ImageFormatConstraintsInfoFUCHSIAX &
+  operator=(ImageFormatConstraintsInfoFUCHSIAX const &rhs)
+      VULKAN_HPP_NOEXCEPT = default;
+
+  ImageFormatConstraintsInfoFUCHSIAX &operator=(
+      VkImageFormatConstraintsInfoFUCHSIAX const &rhs) VULKAN_HPP_NOEXCEPT {
+    *this = *reinterpret_cast<
+        VULKAN_HPP_NAMESPACE::ImageFormatConstraintsInfoFUCHSIAX const *>(&rhs);
+    return *this;
+  }
+
+  ImageFormatConstraintsInfoFUCHSIAX &
+  setPNext(const void *pNext_) VULKAN_HPP_NOEXCEPT {
+    pNext = pNext_;
+    return *this;
+  }
+
+  ImageFormatConstraintsInfoFUCHSIAX &setRequiredFormatFeatures(
+      VULKAN_HPP_NAMESPACE::FormatFeatureFlags requiredFormatFeatures_)
+      VULKAN_HPP_NOEXCEPT {
+    requiredFormatFeatures = requiredFormatFeatures_;
+    return *this;
+  }
+
+  ImageFormatConstraintsInfoFUCHSIAX &
+  setFlags(VULKAN_HPP_NAMESPACE::ImageFormatConstraintsFlagsFUCHSIAX flags_)
+      VULKAN_HPP_NOEXCEPT {
+    flags = flags_;
+    return *this;
+  }
+
+  ImageFormatConstraintsInfoFUCHSIAX &
+  setSysmemFormat(uint64_t sysmemFormat_) VULKAN_HPP_NOEXCEPT {
+    sysmemFormat = sysmemFormat_;
+    return *this;
+  }
+
+  ImageFormatConstraintsInfoFUCHSIAX &
+  setColorSpaceCount(uint32_t colorSpaceCount_) VULKAN_HPP_NOEXCEPT {
+    colorSpaceCount = colorSpaceCount_;
+    return *this;
+  }
+
+  ImageFormatConstraintsInfoFUCHSIAX &setPColorSpaces(
+      const VULKAN_HPP_NAMESPACE::SysmemColorSpaceFUCHSIAX *pColorSpaces_)
+      VULKAN_HPP_NOEXCEPT {
+    pColorSpaces = pColorSpaces_;
+    return *this;
+  }
+
+  operator VkImageFormatConstraintsInfoFUCHSIAX const &() const
+      VULKAN_HPP_NOEXCEPT {
+    return *reinterpret_cast<const VkImageFormatConstraintsInfoFUCHSIAX *>(
+        this);
+  }
+
+  operator VkImageFormatConstraintsInfoFUCHSIAX &() VULKAN_HPP_NOEXCEPT {
+    return *reinterpret_cast<VkImageFormatConstraintsInfoFUCHSIAX *>(this);
+  }
+
+#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
+  auto operator<=>(ImageFormatConstraintsInfoFUCHSIAX const &) const = default;
+#else
+  bool operator==(ImageFormatConstraintsInfoFUCHSIAX const &rhs) const
+      VULKAN_HPP_NOEXCEPT {
+    return (sType == rhs.sType) && (pNext == rhs.pNext) &&
+           (requiredFormatFeatures == rhs.requiredFormatFeatures) &&
+           (flags == rhs.flags) && (sysmemFormat == rhs.sysmemFormat) &&
+           (colorSpaceCount == rhs.colorSpaceCount) &&
+           (pColorSpaces == rhs.pColorSpaces);
+  }
+
+  bool operator!=(ImageFormatConstraintsInfoFUCHSIAX const &rhs) const
+      VULKAN_HPP_NOEXCEPT {
+    return !operator==(rhs);
+  }
+#endif
+
+public:
+  VULKAN_HPP_NAMESPACE::StructureType sType =
+      StructureType::eImageFormatConstraintsInfoFuchsiax;
+  const void *pNext = {};
+  VULKAN_HPP_NAMESPACE::FormatFeatureFlags requiredFormatFeatures = {};
+  VULKAN_HPP_NAMESPACE::ImageFormatConstraintsFlagsFUCHSIAX flags = {};
+  uint64_t sysmemFormat = {};
+  uint32_t colorSpaceCount = {};
+  const VULKAN_HPP_NAMESPACE::SysmemColorSpaceFUCHSIAX *pColorSpaces = {};
+};
+static_assert(sizeof(ImageFormatConstraintsInfoFUCHSIAX) ==
+                  sizeof(VkImageFormatConstraintsInfoFUCHSIAX),
+              "struct and wrapper have different size!");
+static_assert(
+    std::is_standard_layout<ImageFormatConstraintsInfoFUCHSIAX>::value,
+    "struct wrapper is not a standard layout!");
+
+template <>
+struct CppType<StructureType,
+               StructureType::eImageFormatConstraintsInfoFuchsiax> {
+  using Type = ImageFormatConstraintsInfoFUCHSIAX;
+};
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+struct ImageConstraintsInfoFUCHSIAX {
+  static const bool allowDuplicate = false;
+  static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType =
+      StructureType::eImageConstraintsInfoFuchsiax;
+
+#if !defined(VULKAN_HPP_NO_STRUCT_CONSTRUCTORS)
+  VULKAN_HPP_CONSTEXPR ImageConstraintsInfoFUCHSIAX(
+      uint32_t createInfoCount_ = {},
+      const VULKAN_HPP_NAMESPACE::ImageCreateInfo *pCreateInfos_ = {},
+      const VULKAN_HPP_NAMESPACE::ImageFormatConstraintsInfoFUCHSIAX
+          *pFormatConstraints_ = {},
+      uint32_t minBufferCount_ = {}, uint32_t maxBufferCount_ = {},
+      uint32_t minBufferCountForCamping_ = {},
+      uint32_t minBufferCountForDedicatedSlack_ = {},
+      uint32_t minBufferCountForSharedSlack_ = {},
+      VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFlagsFUCHSIAX flags_ = {})
+      VULKAN_HPP_NOEXCEPT
+      : createInfoCount(createInfoCount_),
+        pCreateInfos(pCreateInfos_),
+        pFormatConstraints(pFormatConstraints_),
+        minBufferCount(minBufferCount_),
+        maxBufferCount(maxBufferCount_),
+        minBufferCountForCamping(minBufferCountForCamping_),
+        minBufferCountForDedicatedSlack(minBufferCountForDedicatedSlack_),
+        minBufferCountForSharedSlack(minBufferCountForSharedSlack_),
+        flags(flags_) {}
+
+  VULKAN_HPP_CONSTEXPR ImageConstraintsInfoFUCHSIAX(
+      ImageConstraintsInfoFUCHSIAX const &rhs) VULKAN_HPP_NOEXCEPT = default;
+
+  ImageConstraintsInfoFUCHSIAX(VkImageConstraintsInfoFUCHSIAX const &rhs)
+      VULKAN_HPP_NOEXCEPT
+      : ImageConstraintsInfoFUCHSIAX(
+            *reinterpret_cast<ImageConstraintsInfoFUCHSIAX const *>(&rhs)) {}
+
+#if !defined(VULKAN_HPP_DISABLE_ENHANCED_MODE)
+  ImageConstraintsInfoFUCHSIAX(
+      VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<
+          const VULKAN_HPP_NAMESPACE::ImageCreateInfo> const &createInfos_,
+      VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<
+          const VULKAN_HPP_NAMESPACE::ImageFormatConstraintsInfoFUCHSIAX> const
+          &formatConstraints_ = {},
+      uint32_t minBufferCount_ = {}, uint32_t maxBufferCount_ = {},
+      uint32_t minBufferCountForCamping_ = {},
+      uint32_t minBufferCountForDedicatedSlack_ = {},
+      uint32_t minBufferCountForSharedSlack_ = {},
+      VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFlagsFUCHSIAX flags_ = {})
+      : createInfoCount(static_cast<uint32_t>(createInfos_.size())),
+        pCreateInfos(createInfos_.data()),
+        pFormatConstraints(formatConstraints_.data()),
+        minBufferCount(minBufferCount_), maxBufferCount(maxBufferCount_),
+        minBufferCountForCamping(minBufferCountForCamping_),
+        minBufferCountForDedicatedSlack(minBufferCountForDedicatedSlack_),
+        minBufferCountForSharedSlack(minBufferCountForSharedSlack_),
+        flags(flags_) {
+#ifdef VULKAN_HPP_NO_EXCEPTIONS
+    VULKAN_HPP_ASSERT(formatConstraints_.empty() ||
+                      (createInfos_.size() == formatConstraints_.size()));
+#else
+    if (!formatConstraints_.empty() &&
+        (createInfos_.size() != formatConstraints_.size())) {
+      throw LogicError(
+          VULKAN_HPP_NAMESPACE_STRING
+          "::ImageConstraintsInfoFUCHSIAX::ImageConstraintsInfoFUCHSIAX: "
+          "!formatConstraints_.empty() && ( createInfos_.size() != "
+          "formatConstraints_.size() )");
+    }
+#endif /*VULKAN_HPP_NO_EXCEPTIONS*/
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+  VULKAN_HPP_CONSTEXPR_14 ImageConstraintsInfoFUCHSIAX &operator=(
+      ImageConstraintsInfoFUCHSIAX const &rhs) VULKAN_HPP_NOEXCEPT = default;
+
+  ImageConstraintsInfoFUCHSIAX &
+  operator=(VkImageConstraintsInfoFUCHSIAX const &rhs) VULKAN_HPP_NOEXCEPT {
+    *this = *reinterpret_cast<
+        VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIAX const *>(&rhs);
+    return *this;
+  }
+
+  ImageConstraintsInfoFUCHSIAX &
+  setPNext(const void *pNext_) VULKAN_HPP_NOEXCEPT {
+    pNext = pNext_;
+    return *this;
+  }
+
+  ImageConstraintsInfoFUCHSIAX &
+  setCreateInfoCount(uint32_t createInfoCount_) VULKAN_HPP_NOEXCEPT {
+    createInfoCount = createInfoCount_;
+    return *this;
+  }
+
+  ImageConstraintsInfoFUCHSIAX &
+  setPCreateInfos(const VULKAN_HPP_NAMESPACE::ImageCreateInfo *pCreateInfos_)
+      VULKAN_HPP_NOEXCEPT {
+    pCreateInfos = pCreateInfos_;
+    return *this;
+  }
+
+#if !defined(VULKAN_HPP_DISABLE_ENHANCED_MODE)
+  ImageConstraintsInfoFUCHSIAX &setCreateInfos(
+      VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<
+          const VULKAN_HPP_NAMESPACE::ImageCreateInfo> const &createInfos_)
+      VULKAN_HPP_NOEXCEPT {
+    createInfoCount = static_cast<uint32_t>(createInfos_.size());
+    pCreateInfos = createInfos_.data();
+    return *this;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  ImageConstraintsInfoFUCHSIAX &setPFormatConstraints(
+      const VULKAN_HPP_NAMESPACE::ImageFormatConstraintsInfoFUCHSIAX
+          *pFormatConstraints_) VULKAN_HPP_NOEXCEPT {
+    pFormatConstraints = pFormatConstraints_;
+    return *this;
+  }
+
+#if !defined(VULKAN_HPP_DISABLE_ENHANCED_MODE)
+  ImageConstraintsInfoFUCHSIAX &setFormatConstraints(
+      VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<
+          const VULKAN_HPP_NAMESPACE::ImageFormatConstraintsInfoFUCHSIAX> const
+          &formatConstraints_) VULKAN_HPP_NOEXCEPT {
+    createInfoCount = static_cast<uint32_t>(formatConstraints_.size());
+    pFormatConstraints = formatConstraints_.data();
+    return *this;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  ImageConstraintsInfoFUCHSIAX &
+  setMinBufferCount(uint32_t minBufferCount_) VULKAN_HPP_NOEXCEPT {
+    minBufferCount = minBufferCount_;
+    return *this;
+  }
+
+  ImageConstraintsInfoFUCHSIAX &
+  setMaxBufferCount(uint32_t maxBufferCount_) VULKAN_HPP_NOEXCEPT {
+    maxBufferCount = maxBufferCount_;
+    return *this;
+  }
+
+  ImageConstraintsInfoFUCHSIAX &setMinBufferCountForCamping(
+      uint32_t minBufferCountForCamping_) VULKAN_HPP_NOEXCEPT {
+    minBufferCountForCamping = minBufferCountForCamping_;
+    return *this;
+  }
+
+  ImageConstraintsInfoFUCHSIAX &setMinBufferCountForDedicatedSlack(
+      uint32_t minBufferCountForDedicatedSlack_) VULKAN_HPP_NOEXCEPT {
+    minBufferCountForDedicatedSlack = minBufferCountForDedicatedSlack_;
+    return *this;
+  }
+
+  ImageConstraintsInfoFUCHSIAX &setMinBufferCountForSharedSlack(
+      uint32_t minBufferCountForSharedSlack_) VULKAN_HPP_NOEXCEPT {
+    minBufferCountForSharedSlack = minBufferCountForSharedSlack_;
+    return *this;
+  }
+
+  ImageConstraintsInfoFUCHSIAX &
+  setFlags(VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFlagsFUCHSIAX flags_)
+      VULKAN_HPP_NOEXCEPT {
+    flags = flags_;
+    return *this;
+  }
+
+  operator VkImageConstraintsInfoFUCHSIAX const &() const VULKAN_HPP_NOEXCEPT {
+    return *reinterpret_cast<const VkImageConstraintsInfoFUCHSIAX *>(this);
+  }
+
+  operator VkImageConstraintsInfoFUCHSIAX &() VULKAN_HPP_NOEXCEPT {
+    return *reinterpret_cast<VkImageConstraintsInfoFUCHSIAX *>(this);
+  }
+
+#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
+  auto operator<=>(ImageConstraintsInfoFUCHSIAX const &) const = default;
+#else
+  bool operator==(ImageConstraintsInfoFUCHSIAX const &rhs) const
+      VULKAN_HPP_NOEXCEPT {
+    return (sType == rhs.sType) && (pNext == rhs.pNext) &&
+           (createInfoCount == rhs.createInfoCount) &&
+           (pCreateInfos == rhs.pCreateInfos) &&
+           (pFormatConstraints == rhs.pFormatConstraints) &&
+           (minBufferCount == rhs.minBufferCount) &&
+           (maxBufferCount == rhs.maxBufferCount) &&
+           (minBufferCountForCamping == rhs.minBufferCountForCamping) &&
+           (minBufferCountForDedicatedSlack ==
+            rhs.minBufferCountForDedicatedSlack) &&
+           (minBufferCountForSharedSlack == rhs.minBufferCountForSharedSlack) &&
+           (flags == rhs.flags);
+  }
+
+  bool operator!=(ImageConstraintsInfoFUCHSIAX const &rhs) const
+      VULKAN_HPP_NOEXCEPT {
+    return !operator==(rhs);
+  }
+#endif
+
+public:
+  VULKAN_HPP_NAMESPACE::StructureType sType =
+      StructureType::eImageConstraintsInfoFuchsiax;
+  const void *pNext = {};
+  uint32_t createInfoCount = {};
+  const VULKAN_HPP_NAMESPACE::ImageCreateInfo *pCreateInfos = {};
+  const VULKAN_HPP_NAMESPACE::ImageFormatConstraintsInfoFUCHSIAX
+      *pFormatConstraints = {};
+  uint32_t minBufferCount = {};
+  uint32_t maxBufferCount = {};
+  uint32_t minBufferCountForCamping = {};
+  uint32_t minBufferCountForDedicatedSlack = {};
+  uint32_t minBufferCountForSharedSlack = {};
+  VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFlagsFUCHSIAX flags = {};
+};
+static_assert(sizeof(ImageConstraintsInfoFUCHSIAX) ==
+                  sizeof(VkImageConstraintsInfoFUCHSIAX),
+              "struct and wrapper have different size!");
+static_assert(std::is_standard_layout<ImageConstraintsInfoFUCHSIAX>::value,
+              "struct wrapper is not a standard layout!");
+
+template <>
+struct CppType<StructureType, StructureType::eImageConstraintsInfoFuchsiax> {
+  using Type = ImageConstraintsInfoFUCHSIAX;
+};
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+
 struct XYColorEXT {
 
 #if !defined(VULKAN_HPP_NO_STRUCT_CONSTRUCTORS)
@@ -56988,6 +59191,15 @@
 using UniqueBufferCollectionFUCHSIA =
     UniqueHandle<BufferCollectionFUCHSIA, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+template <typename Dispatch>
+class UniqueHandleTraits<BufferCollectionFUCHSIAX, Dispatch> {
+public:
+  using deleter = ObjectDestroy<Device, Dispatch>;
+};
+using UniqueBufferCollectionFUCHSIAX =
+    UniqueHandle<BufferCollectionFUCHSIAX, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
 template <typename Dispatch> class UniqueHandleTraits<BufferView, Dispatch> {
 public:
   using deleter = ObjectDestroy<Device, Dispatch>;
@@ -57734,6 +59946,38 @@
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+  VULKAN_HPP_NODISCARD Result createBufferCollectionFUCHSIAX(
+      const VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIAX
+          *pImportInfo,
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator,
+      VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIAX *pCollection,
+      Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
+      VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<
+      VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIAX>::type
+  createBufferCollectionFUCHSIAX(
+      const BufferCollectionCreateInfoFUCHSIAX &importInfo,
+      Optional<const AllocationCallbacks> allocator
+          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+      Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<
+          VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIAX, Dispatch>>::type
+      createBufferCollectionFUCHSIAXUnique(
+          const BufferCollectionCreateInfoFUCHSIAX &importInfo,
+          Optional<const AllocationCallbacks> allocator
+              VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+          Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+
   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
   VULKAN_HPP_NODISCARD Result createBufferView(
       const VULKAN_HPP_NAMESPACE::BufferViewCreateInfo *pCreateInfo,
@@ -59105,6 +61349,40 @@
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+  void destroyBufferCollectionFUCHSIAX(
+      VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIAX collection,
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator,
+      Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
+      VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+  void destroyBufferCollectionFUCHSIAX(
+      VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIAX collection,
+      Optional<const AllocationCallbacks> allocator
+          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+      Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
+      VULKAN_HPP_NOEXCEPT;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+  void destroy(VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIAX collection,
+               const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator,
+               Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
+      VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+  void destroy(VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIAX collection,
+               Optional<const AllocationCallbacks> allocator
+                   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+               Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
+      VULKAN_HPP_NOEXCEPT;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+
   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
   void
   destroyBufferView(VULKAN_HPP_NAMESPACE::BufferView bufferView,
@@ -59278,6 +61556,22 @@
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+  void destroy(
+      VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
+      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator,
+      Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
+      VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+  void destroy(
+      VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
+      Optional<const AllocationCallbacks> allocator
+          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+      Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
+      VULKAN_HPP_NOEXCEPT;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
   void destroyDescriptorUpdateTemplateKHR(
       VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator,
@@ -59295,22 +61589,6 @@
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-  void destroy(
-      VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
-      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator,
-      Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
-      VULKAN_HPP_NOEXCEPT;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-  void destroy(
-      VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
-      Optional<const AllocationCallbacks> allocator
-          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-      Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
-      VULKAN_HPP_NOEXCEPT;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
   void destroy(const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator,
                Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
       VULKAN_HPP_NOEXCEPT;
@@ -59739,6 +62017,20 @@
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+  void destroy(VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion,
+               const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator,
+               Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
+      VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+  void destroy(VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion,
+               Optional<const AllocationCallbacks> allocator
+                   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+               Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
+      VULKAN_HPP_NOEXCEPT;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
   void destroySamplerYcbcrConversionKHR(
       VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion,
       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator,
@@ -59756,20 +62048,6 @@
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-  void destroy(VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion,
-               const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator,
-               Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
-      VULKAN_HPP_NOEXCEPT;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-  void destroy(VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion,
-               Optional<const AllocationCallbacks> allocator
-                   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-               Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
-      VULKAN_HPP_NOEXCEPT;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
   void
   destroySemaphore(VULKAN_HPP_NAMESPACE::Semaphore semaphore,
                    const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator,
@@ -60155,6 +62433,23 @@
 
 #if defined(VK_USE_PLATFORM_FUCHSIA)
   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+  VULKAN_HPP_NODISCARD Result getBufferCollectionProperties2FUCHSIAX(
+      VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIAX collection,
+      VULKAN_HPP_NAMESPACE::BufferCollectionProperties2FUCHSIAX *pProperties,
+      Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
+      VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<
+      VULKAN_HPP_NAMESPACE::BufferCollectionProperties2FUCHSIAX>::type
+  getBufferCollectionProperties2FUCHSIAX(
+      VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIAX collection,
+      Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
   VULKAN_HPP_NODISCARD Result getBufferCollectionPropertiesFUCHSIA(
       VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection,
       VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA *pProperties,
@@ -60170,6 +62465,23 @@
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+  VULKAN_HPP_NODISCARD Result getBufferCollectionPropertiesFUCHSIAX(
+      VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIAX collection,
+      VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIAX *pProperties,
+      Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
+      VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<
+      VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIAX>::type
+  getBufferCollectionPropertiesFUCHSIAX(
+      VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIAX collection,
+      Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+
   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
   DeviceAddress
   getBufferAddress(const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo *pInfo,
@@ -61971,6 +64283,24 @@
 
 #if defined(VK_USE_PLATFORM_FUCHSIA)
   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+  VULKAN_HPP_NODISCARD Result setBufferCollectionBufferConstraintsFUCHSIAX(
+      VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIAX collection,
+      const VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIAX
+          *pBufferConstraintsInfo,
+      Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
+      VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
+  setBufferCollectionBufferConstraintsFUCHSIAX(
+      VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIAX collection,
+      const BufferConstraintsInfoFUCHSIAX &bufferConstraintsInfo,
+      Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
   VULKAN_HPP_NODISCARD Result setBufferCollectionConstraintsFUCHSIA(
       VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection,
       const VULKAN_HPP_NAMESPACE::ImageCreateInfo *pImageInfo,
@@ -61988,6 +64318,23 @@
 
 #if defined(VK_USE_PLATFORM_FUCHSIA)
   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+  VULKAN_HPP_NODISCARD Result setBufferCollectionConstraintsFUCHSIAX(
+      VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIAX collection,
+      const VULKAN_HPP_NAMESPACE::ImageCreateInfo *pImageInfo,
+      Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
+      VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
+  setBufferCollectionConstraintsFUCHSIAX(
+      VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIAX collection,
+      const ImageCreateInfo &imageInfo,
+      Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
   VULKAN_HPP_NODISCARD Result setBufferCollectionImageConstraintsFUCHSIA(
       VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection,
       const VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA
@@ -62004,6 +64351,24 @@
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+  VULKAN_HPP_NODISCARD Result setBufferCollectionImageConstraintsFUCHSIAX(
+      VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIAX collection,
+      const VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIAX
+          *pImageConstraintsInfo,
+      Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
+      VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
+  setBufferCollectionImageConstraintsFUCHSIAX(
+      VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIAX collection,
+      const ImageConstraintsInfoFUCHSIAX &imageConstraintsInfo,
+      Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+
   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
   VULKAN_HPP_NODISCARD Result setDebugUtilsObjectNameEXT(
       const VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT *pNameInfo,
@@ -73626,6 +75991,107 @@
 };
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+struct ImportMemoryBufferCollectionFUCHSIAX {
+  static const bool allowDuplicate = false;
+  static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType =
+      StructureType::eImportMemoryBufferCollectionFuchsiax;
+
+#if !defined(VULKAN_HPP_NO_STRUCT_CONSTRUCTORS)
+  VULKAN_HPP_CONSTEXPR ImportMemoryBufferCollectionFUCHSIAX(
+      VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIAX collection_ = {},
+      uint32_t index_ = {}) VULKAN_HPP_NOEXCEPT : collection(collection_),
+                                                  index(index_) {}
+
+  VULKAN_HPP_CONSTEXPR ImportMemoryBufferCollectionFUCHSIAX(
+      ImportMemoryBufferCollectionFUCHSIAX const &rhs)
+      VULKAN_HPP_NOEXCEPT = default;
+
+  ImportMemoryBufferCollectionFUCHSIAX(
+      VkImportMemoryBufferCollectionFUCHSIAX const &rhs) VULKAN_HPP_NOEXCEPT
+      : ImportMemoryBufferCollectionFUCHSIAX(
+            *reinterpret_cast<ImportMemoryBufferCollectionFUCHSIAX const *>(
+                &rhs)) {}
+#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+  VULKAN_HPP_CONSTEXPR_14 ImportMemoryBufferCollectionFUCHSIAX &
+  operator=(ImportMemoryBufferCollectionFUCHSIAX const &rhs)
+      VULKAN_HPP_NOEXCEPT = default;
+
+  ImportMemoryBufferCollectionFUCHSIAX &operator=(
+      VkImportMemoryBufferCollectionFUCHSIAX const &rhs) VULKAN_HPP_NOEXCEPT {
+    *this = *reinterpret_cast<
+        VULKAN_HPP_NAMESPACE::ImportMemoryBufferCollectionFUCHSIAX const *>(
+        &rhs);
+    return *this;
+  }
+
+  ImportMemoryBufferCollectionFUCHSIAX &
+  setPNext(const void *pNext_) VULKAN_HPP_NOEXCEPT {
+    pNext = pNext_;
+    return *this;
+  }
+
+  ImportMemoryBufferCollectionFUCHSIAX &
+  setCollection(VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIAX collection_)
+      VULKAN_HPP_NOEXCEPT {
+    collection = collection_;
+    return *this;
+  }
+
+  ImportMemoryBufferCollectionFUCHSIAX &
+  setIndex(uint32_t index_) VULKAN_HPP_NOEXCEPT {
+    index = index_;
+    return *this;
+  }
+
+  operator VkImportMemoryBufferCollectionFUCHSIAX const &() const
+      VULKAN_HPP_NOEXCEPT {
+    return *reinterpret_cast<const VkImportMemoryBufferCollectionFUCHSIAX *>(
+        this);
+  }
+
+  operator VkImportMemoryBufferCollectionFUCHSIAX &() VULKAN_HPP_NOEXCEPT {
+    return *reinterpret_cast<VkImportMemoryBufferCollectionFUCHSIAX *>(this);
+  }
+
+#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
+  auto
+  operator<=>(ImportMemoryBufferCollectionFUCHSIAX const &) const = default;
+#else
+  bool operator==(ImportMemoryBufferCollectionFUCHSIAX const &rhs) const
+      VULKAN_HPP_NOEXCEPT {
+    return (sType == rhs.sType) && (pNext == rhs.pNext) &&
+           (collection == rhs.collection) && (index == rhs.index);
+  }
+
+  bool operator!=(ImportMemoryBufferCollectionFUCHSIAX const &rhs) const
+      VULKAN_HPP_NOEXCEPT {
+    return !operator==(rhs);
+  }
+#endif
+
+public:
+  VULKAN_HPP_NAMESPACE::StructureType sType =
+      StructureType::eImportMemoryBufferCollectionFuchsiax;
+  const void *pNext = {};
+  VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIAX collection = {};
+  uint32_t index = {};
+};
+static_assert(sizeof(ImportMemoryBufferCollectionFUCHSIAX) ==
+                  sizeof(VkImportMemoryBufferCollectionFUCHSIAX),
+              "struct and wrapper have different size!");
+static_assert(
+    std::is_standard_layout<ImportMemoryBufferCollectionFUCHSIAX>::value,
+    "struct wrapper is not a standard layout!");
+
+template <>
+struct CppType<StructureType,
+               StructureType::eImportMemoryBufferCollectionFuchsiax> {
+  using Type = ImportMemoryBufferCollectionFUCHSIAX;
+};
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+
 struct ImportMemoryFdInfoKHR {
   static const bool allowDuplicate = false;
   static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType =
@@ -104084,6 +106550,75 @@
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+template <typename Dispatch>
+VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+Device::createBufferCollectionFUCHSIAX(
+    const VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIAX *pImportInfo,
+    const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator,
+    VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIAX *pCollection,
+    Dispatch const &d) const VULKAN_HPP_NOEXCEPT {
+  return static_cast<Result>(d.vkCreateBufferCollectionFUCHSIAX(
+      m_device,
+      reinterpret_cast<const VkBufferCollectionCreateInfoFUCHSIAX *>(
+          pImportInfo),
+      reinterpret_cast<const VkAllocationCallbacks *>(pAllocator),
+      reinterpret_cast<VkBufferCollectionFUCHSIAX *>(pCollection)));
+}
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+template <typename Dispatch>
+VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<
+        VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIAX>::type
+    Device::createBufferCollectionFUCHSIAX(
+        const BufferCollectionCreateInfoFUCHSIAX &importInfo,
+        Optional<const AllocationCallbacks> allocator,
+        Dispatch const &d) const {
+  VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIAX collection;
+  Result result = static_cast<Result>(d.vkCreateBufferCollectionFUCHSIAX(
+      m_device,
+      reinterpret_cast<const VkBufferCollectionCreateInfoFUCHSIAX *>(
+          &importInfo),
+      reinterpret_cast<const VkAllocationCallbacks *>(
+          static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(
+              allocator)),
+      reinterpret_cast<VkBufferCollectionFUCHSIAX *>(&collection)));
+  return createResultValue(result, collection,
+                           VULKAN_HPP_NAMESPACE_STRING
+                           "::Device::createBufferCollectionFUCHSIAX");
+}
+
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+template <typename Dispatch>
+VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<UniqueHandle<
+        VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIAX, Dispatch>>::type
+    Device::createBufferCollectionFUCHSIAXUnique(
+        const BufferCollectionCreateInfoFUCHSIAX &importInfo,
+        Optional<const AllocationCallbacks> allocator,
+        Dispatch const &d) const {
+  VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIAX collection;
+  Result result = static_cast<Result>(d.vkCreateBufferCollectionFUCHSIAX(
+      m_device,
+      reinterpret_cast<const VkBufferCollectionCreateInfoFUCHSIAX *>(
+          &importInfo),
+      reinterpret_cast<const VkAllocationCallbacks *>(
+          static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(
+              allocator)),
+      reinterpret_cast<VkBufferCollectionFUCHSIAX *>(&collection)));
+  ObjectDestroy<Device, Dispatch> deleter(*this, allocator, d);
+  return createResultValue<VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIAX,
+                           Dispatch>(
+      result, collection,
+      VULKAN_HPP_NAMESPACE_STRING
+      "::Device::createBufferCollectionFUCHSIAXUnique",
+      deleter);
+}
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+
 template <typename Dispatch>
 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createBufferView(
     const VULKAN_HPP_NAMESPACE::BufferViewCreateInfo *pCreateInfo,
@@ -106883,6 +109418,58 @@
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+template <typename Dispatch>
+VULKAN_HPP_INLINE void Device::destroyBufferCollectionFUCHSIAX(
+    VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIAX collection,
+    const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator,
+    Dispatch const &d) const VULKAN_HPP_NOEXCEPT {
+  d.vkDestroyBufferCollectionFUCHSIAX(
+      m_device, static_cast<VkBufferCollectionFUCHSIAX>(collection),
+      reinterpret_cast<const VkAllocationCallbacks *>(pAllocator));
+}
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+template <typename Dispatch>
+VULKAN_HPP_INLINE void Device::destroyBufferCollectionFUCHSIAX(
+    VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIAX collection,
+    Optional<const AllocationCallbacks> allocator,
+    Dispatch const &d) const VULKAN_HPP_NOEXCEPT {
+  d.vkDestroyBufferCollectionFUCHSIAX(
+      m_device, static_cast<VkBufferCollectionFUCHSIAX>(collection),
+      reinterpret_cast<const VkAllocationCallbacks *>(
+          static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(
+              allocator)));
+}
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+template <typename Dispatch>
+VULKAN_HPP_INLINE void
+Device::destroy(VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIAX collection,
+                const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator,
+                Dispatch const &d) const VULKAN_HPP_NOEXCEPT {
+  d.vkDestroyBufferCollectionFUCHSIAX(
+      m_device, static_cast<VkBufferCollectionFUCHSIAX>(collection),
+      reinterpret_cast<const VkAllocationCallbacks *>(pAllocator));
+}
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+template <typename Dispatch>
+VULKAN_HPP_INLINE void
+Device::destroy(VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIAX collection,
+                Optional<const AllocationCallbacks> allocator,
+                Dispatch const &d) const VULKAN_HPP_NOEXCEPT {
+  d.vkDestroyBufferCollectionFUCHSIAX(
+      m_device, static_cast<VkBufferCollectionFUCHSIAX>(collection),
+      reinterpret_cast<const VkAllocationCallbacks *>(
+          static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(
+              allocator)));
+}
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+
 template <typename Dispatch>
 VULKAN_HPP_INLINE void Device::destroyBufferView(
     VULKAN_HPP_NAMESPACE::BufferView bufferView,
@@ -107150,11 +109737,11 @@
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
 template <typename Dispatch>
-VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplateKHR(
+VULKAN_HPP_INLINE void Device::destroy(
     VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
     const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator,
     Dispatch const &d) const VULKAN_HPP_NOEXCEPT {
-  d.vkDestroyDescriptorUpdateTemplateKHR(
+  d.vkDestroyDescriptorUpdateTemplate(
       m_device,
       static_cast<VkDescriptorUpdateTemplate>(descriptorUpdateTemplate),
       reinterpret_cast<const VkAllocationCallbacks *>(pAllocator));
@@ -107162,11 +109749,11 @@
 
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
 template <typename Dispatch>
-VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplateKHR(
+VULKAN_HPP_INLINE void Device::destroy(
     VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
     Optional<const AllocationCallbacks> allocator,
     Dispatch const &d) const VULKAN_HPP_NOEXCEPT {
-  d.vkDestroyDescriptorUpdateTemplateKHR(
+  d.vkDestroyDescriptorUpdateTemplate(
       m_device,
       static_cast<VkDescriptorUpdateTemplate>(descriptorUpdateTemplate),
       reinterpret_cast<const VkAllocationCallbacks *>(
@@ -107176,11 +109763,11 @@
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
 template <typename Dispatch>
-VULKAN_HPP_INLINE void Device::destroy(
+VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplateKHR(
     VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
     const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator,
     Dispatch const &d) const VULKAN_HPP_NOEXCEPT {
-  d.vkDestroyDescriptorUpdateTemplate(
+  d.vkDestroyDescriptorUpdateTemplateKHR(
       m_device,
       static_cast<VkDescriptorUpdateTemplate>(descriptorUpdateTemplate),
       reinterpret_cast<const VkAllocationCallbacks *>(pAllocator));
@@ -107188,11 +109775,11 @@
 
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
 template <typename Dispatch>
-VULKAN_HPP_INLINE void Device::destroy(
+VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplateKHR(
     VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
     Optional<const AllocationCallbacks> allocator,
     Dispatch const &d) const VULKAN_HPP_NOEXCEPT {
-  d.vkDestroyDescriptorUpdateTemplate(
+  d.vkDestroyDescriptorUpdateTemplateKHR(
       m_device,
       static_cast<VkDescriptorUpdateTemplate>(descriptorUpdateTemplate),
       reinterpret_cast<const VkAllocationCallbacks *>(
@@ -107865,30 +110452,6 @@
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
 template <typename Dispatch>
-VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversionKHR(
-    VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion,
-    const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator,
-    Dispatch const &d) const VULKAN_HPP_NOEXCEPT {
-  d.vkDestroySamplerYcbcrConversionKHR(
-      m_device, static_cast<VkSamplerYcbcrConversion>(ycbcrConversion),
-      reinterpret_cast<const VkAllocationCallbacks *>(pAllocator));
-}
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-template <typename Dispatch>
-VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversionKHR(
-    VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion,
-    Optional<const AllocationCallbacks> allocator,
-    Dispatch const &d) const VULKAN_HPP_NOEXCEPT {
-  d.vkDestroySamplerYcbcrConversionKHR(
-      m_device, static_cast<VkSamplerYcbcrConversion>(ycbcrConversion),
-      reinterpret_cast<const VkAllocationCallbacks *>(
-          static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(
-              allocator)));
-}
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-template <typename Dispatch>
 VULKAN_HPP_INLINE void
 Device::destroy(VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion,
                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator,
@@ -107913,6 +110476,30 @@
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
 template <typename Dispatch>
+VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversionKHR(
+    VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion,
+    const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator,
+    Dispatch const &d) const VULKAN_HPP_NOEXCEPT {
+  d.vkDestroySamplerYcbcrConversionKHR(
+      m_device, static_cast<VkSamplerYcbcrConversion>(ycbcrConversion),
+      reinterpret_cast<const VkAllocationCallbacks *>(pAllocator));
+}
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+template <typename Dispatch>
+VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversionKHR(
+    VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion,
+    Optional<const AllocationCallbacks> allocator,
+    Dispatch const &d) const VULKAN_HPP_NOEXCEPT {
+  d.vkDestroySamplerYcbcrConversionKHR(
+      m_device, static_cast<VkSamplerYcbcrConversion>(ycbcrConversion),
+      reinterpret_cast<const VkAllocationCallbacks *>(
+          static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>(
+              allocator)));
+}
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+template <typename Dispatch>
 VULKAN_HPP_INLINE void Device::destroySemaphore(
     VULKAN_HPP_NAMESPACE::Semaphore semaphore,
     const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator,
@@ -108579,6 +111166,39 @@
 #if defined(VK_USE_PLATFORM_FUCHSIA)
 template <typename Dispatch>
 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+Device::getBufferCollectionProperties2FUCHSIAX(
+    VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIAX collection,
+    VULKAN_HPP_NAMESPACE::BufferCollectionProperties2FUCHSIAX *pProperties,
+    Dispatch const &d) const VULKAN_HPP_NOEXCEPT {
+  return static_cast<Result>(d.vkGetBufferCollectionProperties2FUCHSIAX(
+      m_device, static_cast<VkBufferCollectionFUCHSIAX>(collection),
+      reinterpret_cast<VkBufferCollectionProperties2FUCHSIAX *>(pProperties)));
+}
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+template <typename Dispatch>
+VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<
+        VULKAN_HPP_NAMESPACE::BufferCollectionProperties2FUCHSIAX>::type
+    Device::getBufferCollectionProperties2FUCHSIAX(
+        VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIAX collection,
+        Dispatch const &d) const {
+  VULKAN_HPP_NAMESPACE::BufferCollectionProperties2FUCHSIAX properties;
+  Result result =
+      static_cast<Result>(d.vkGetBufferCollectionProperties2FUCHSIAX(
+          m_device, static_cast<VkBufferCollectionFUCHSIAX>(collection),
+          reinterpret_cast<VkBufferCollectionProperties2FUCHSIAX *>(
+              &properties)));
+  return createResultValue(result, properties,
+                           VULKAN_HPP_NAMESPACE_STRING
+                           "::Device::getBufferCollectionProperties2FUCHSIAX");
+}
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+template <typename Dispatch>
+VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
 Device::getBufferCollectionPropertiesFUCHSIA(
     VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection,
     VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA *pProperties,
@@ -108607,6 +111227,37 @@
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+template <typename Dispatch>
+VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+Device::getBufferCollectionPropertiesFUCHSIAX(
+    VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIAX collection,
+    VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIAX *pProperties,
+    Dispatch const &d) const VULKAN_HPP_NOEXCEPT {
+  return static_cast<Result>(d.vkGetBufferCollectionPropertiesFUCHSIAX(
+      m_device, static_cast<VkBufferCollectionFUCHSIAX>(collection),
+      reinterpret_cast<VkBufferCollectionPropertiesFUCHSIAX *>(pProperties)));
+}
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+template <typename Dispatch>
+VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<
+        VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIAX>::type
+    Device::getBufferCollectionPropertiesFUCHSIAX(
+        VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIAX collection,
+        Dispatch const &d) const {
+  VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIAX properties;
+  Result result = static_cast<Result>(d.vkGetBufferCollectionPropertiesFUCHSIAX(
+      m_device, static_cast<VkBufferCollectionFUCHSIAX>(collection),
+      reinterpret_cast<VkBufferCollectionPropertiesFUCHSIAX *>(&properties)));
+  return createResultValue(result, properties,
+                           VULKAN_HPP_NAMESPACE_STRING
+                           "::Device::getBufferCollectionPropertiesFUCHSIAX");
+}
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+
 template <typename Dispatch>
 VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddress(
     const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo *pInfo,
@@ -112097,6 +114748,40 @@
 #if defined(VK_USE_PLATFORM_FUCHSIA)
 template <typename Dispatch>
 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+Device::setBufferCollectionBufferConstraintsFUCHSIAX(
+    VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIAX collection,
+    const VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIAX
+        *pBufferConstraintsInfo,
+    Dispatch const &d) const VULKAN_HPP_NOEXCEPT {
+  return static_cast<Result>(d.vkSetBufferCollectionBufferConstraintsFUCHSIAX(
+      m_device, static_cast<VkBufferCollectionFUCHSIAX>(collection),
+      reinterpret_cast<const VkBufferConstraintsInfoFUCHSIAX *>(
+          pBufferConstraintsInfo)));
+}
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+template <typename Dispatch>
+VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<void>::type
+    Device::setBufferCollectionBufferConstraintsFUCHSIAX(
+        VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIAX collection,
+        const BufferConstraintsInfoFUCHSIAX &bufferConstraintsInfo,
+        Dispatch const &d) const {
+  Result result =
+      static_cast<Result>(d.vkSetBufferCollectionBufferConstraintsFUCHSIAX(
+          m_device, static_cast<VkBufferCollectionFUCHSIAX>(collection),
+          reinterpret_cast<const VkBufferConstraintsInfoFUCHSIAX *>(
+              &bufferConstraintsInfo)));
+  return createResultValue(
+      result, VULKAN_HPP_NAMESPACE_STRING
+      "::Device::setBufferCollectionBufferConstraintsFUCHSIAX");
+}
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+template <typename Dispatch>
+VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
 Device::setBufferCollectionConstraintsFUCHSIA(
     VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection,
     const VULKAN_HPP_NAMESPACE::ImageCreateInfo *pImageInfo,
@@ -112125,6 +114810,35 @@
 #if defined(VK_USE_PLATFORM_FUCHSIA)
 template <typename Dispatch>
 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+Device::setBufferCollectionConstraintsFUCHSIAX(
+    VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIAX collection,
+    const VULKAN_HPP_NAMESPACE::ImageCreateInfo *pImageInfo,
+    Dispatch const &d) const VULKAN_HPP_NOEXCEPT {
+  return static_cast<Result>(d.vkSetBufferCollectionConstraintsFUCHSIAX(
+      m_device, static_cast<VkBufferCollectionFUCHSIAX>(collection),
+      reinterpret_cast<const VkImageCreateInfo *>(pImageInfo)));
+}
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+template <typename Dispatch>
+VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<void>::type
+    Device::setBufferCollectionConstraintsFUCHSIAX(
+        VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIAX collection,
+        const ImageCreateInfo &imageInfo, Dispatch const &d) const {
+  Result result =
+      static_cast<Result>(d.vkSetBufferCollectionConstraintsFUCHSIAX(
+          m_device, static_cast<VkBufferCollectionFUCHSIAX>(collection),
+          reinterpret_cast<const VkImageCreateInfo *>(&imageInfo)));
+  return createResultValue(result, VULKAN_HPP_NAMESPACE_STRING
+                           "::Device::setBufferCollectionConstraintsFUCHSIAX");
+}
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+template <typename Dispatch>
+VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
 Device::setBufferCollectionImageConstraintsFUCHSIA(
     VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection,
     const VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA
@@ -112156,6 +114870,40 @@
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+template <typename Dispatch>
+VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+Device::setBufferCollectionImageConstraintsFUCHSIAX(
+    VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIAX collection,
+    const VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIAX
+        *pImageConstraintsInfo,
+    Dispatch const &d) const VULKAN_HPP_NOEXCEPT {
+  return static_cast<Result>(d.vkSetBufferCollectionImageConstraintsFUCHSIAX(
+      m_device, static_cast<VkBufferCollectionFUCHSIAX>(collection),
+      reinterpret_cast<const VkImageConstraintsInfoFUCHSIAX *>(
+          pImageConstraintsInfo)));
+}
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+template <typename Dispatch>
+VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<void>::type
+    Device::setBufferCollectionImageConstraintsFUCHSIAX(
+        VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIAX collection,
+        const ImageConstraintsInfoFUCHSIAX &imageConstraintsInfo,
+        Dispatch const &d) const {
+  Result result =
+      static_cast<Result>(d.vkSetBufferCollectionImageConstraintsFUCHSIAX(
+          m_device, static_cast<VkBufferCollectionFUCHSIAX>(collection),
+          reinterpret_cast<const VkImageConstraintsInfoFUCHSIAX *>(
+              &imageConstraintsInfo)));
+  return createResultValue(
+      result, VULKAN_HPP_NAMESPACE_STRING
+      "::Device::setBufferCollectionImageConstraintsFUCHSIAX");
+}
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+
 template <typename Dispatch>
 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
 Device::setDebugUtilsObjectNameEXT(
@@ -118147,10 +120895,23 @@
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 #if defined(VK_USE_PLATFORM_FUCHSIA)
 template <>
+struct StructExtends<BufferCollectionBufferCreateInfoFUCHSIAX,
+                     BufferCreateInfo> {
+  enum { value = true };
+};
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+template <>
 struct StructExtends<BufferCollectionImageCreateInfoFUCHSIA, ImageCreateInfo> {
   enum { value = true };
 };
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+template <>
+struct StructExtends<BufferCollectionImageCreateInfoFUCHSIAX, ImageCreateInfo> {
+  enum { value = true };
+};
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
 template <>
 struct StructExtends<BufferDeviceAddressCreateInfoEXT, BufferCreateInfo> {
   enum { value = true };
@@ -118429,6 +121190,12 @@
   enum { value = true };
 };
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+template <>
+struct StructExtends<ImportMemoryBufferCollectionFUCHSIAX, MemoryAllocateInfo> {
+  enum { value = true };
+};
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
 template <> struct StructExtends<ImportMemoryFdInfoKHR, MemoryAllocateInfo> {
   enum { value = true };
 };
@@ -120019,19 +122786,19 @@
   PFN_vkBindAccelerationStructureMemoryNV vkBindAccelerationStructureMemoryNV =
       0;
   PFN_vkBindBufferMemory vkBindBufferMemory = 0;
-  PFN_vkBindBufferMemory2KHR vkBindBufferMemory2KHR = 0;
   PFN_vkBindBufferMemory2 vkBindBufferMemory2 = 0;
+  PFN_vkBindBufferMemory2KHR vkBindBufferMemory2KHR = 0;
   PFN_vkBindImageMemory vkBindImageMemory = 0;
-  PFN_vkBindImageMemory2KHR vkBindImageMemory2KHR = 0;
   PFN_vkBindImageMemory2 vkBindImageMemory2 = 0;
+  PFN_vkBindImageMemory2KHR vkBindImageMemory2KHR = 0;
   PFN_vkBuildAccelerationStructuresKHR vkBuildAccelerationStructuresKHR = 0;
   PFN_vkCmdBeginConditionalRenderingEXT vkCmdBeginConditionalRenderingEXT = 0;
   PFN_vkCmdBeginDebugUtilsLabelEXT vkCmdBeginDebugUtilsLabelEXT = 0;
   PFN_vkCmdBeginQuery vkCmdBeginQuery = 0;
   PFN_vkCmdBeginQueryIndexedEXT vkCmdBeginQueryIndexedEXT = 0;
   PFN_vkCmdBeginRenderPass vkCmdBeginRenderPass = 0;
-  PFN_vkCmdBeginRenderPass2KHR vkCmdBeginRenderPass2KHR = 0;
   PFN_vkCmdBeginRenderPass2 vkCmdBeginRenderPass2 = 0;
+  PFN_vkCmdBeginRenderPass2KHR vkCmdBeginRenderPass2KHR = 0;
   PFN_vkCmdBeginTransformFeedbackEXT vkCmdBeginTransformFeedbackEXT = 0;
   PFN_vkCmdBindDescriptorSets vkCmdBindDescriptorSets = 0;
   PFN_vkCmdBindIndexBuffer vkCmdBindIndexBuffer = 0;
@@ -120071,20 +122838,20 @@
   PFN_vkCmdDebugMarkerEndEXT vkCmdDebugMarkerEndEXT = 0;
   PFN_vkCmdDebugMarkerInsertEXT vkCmdDebugMarkerInsertEXT = 0;
   PFN_vkCmdDispatch vkCmdDispatch = 0;
-  PFN_vkCmdDispatchBaseKHR vkCmdDispatchBaseKHR = 0;
   PFN_vkCmdDispatchBase vkCmdDispatchBase = 0;
+  PFN_vkCmdDispatchBaseKHR vkCmdDispatchBaseKHR = 0;
   PFN_vkCmdDispatchIndirect vkCmdDispatchIndirect = 0;
   PFN_vkCmdDraw vkCmdDraw = 0;
   PFN_vkCmdDrawIndexed vkCmdDrawIndexed = 0;
   PFN_vkCmdDrawIndexedIndirect vkCmdDrawIndexedIndirect = 0;
+  PFN_vkCmdDrawIndexedIndirectCount vkCmdDrawIndexedIndirectCount = 0;
   PFN_vkCmdDrawIndexedIndirectCountAMD vkCmdDrawIndexedIndirectCountAMD = 0;
   PFN_vkCmdDrawIndexedIndirectCountKHR vkCmdDrawIndexedIndirectCountKHR = 0;
-  PFN_vkCmdDrawIndexedIndirectCount vkCmdDrawIndexedIndirectCount = 0;
   PFN_vkCmdDrawIndirect vkCmdDrawIndirect = 0;
   PFN_vkCmdDrawIndirectByteCountEXT vkCmdDrawIndirectByteCountEXT = 0;
+  PFN_vkCmdDrawIndirectCount vkCmdDrawIndirectCount = 0;
   PFN_vkCmdDrawIndirectCountAMD vkCmdDrawIndirectCountAMD = 0;
   PFN_vkCmdDrawIndirectCountKHR vkCmdDrawIndirectCountKHR = 0;
-  PFN_vkCmdDrawIndirectCount vkCmdDrawIndirectCount = 0;
   PFN_vkCmdDrawMeshTasksIndirectCountNV vkCmdDrawMeshTasksIndirectCountNV = 0;
   PFN_vkCmdDrawMeshTasksIndirectNV vkCmdDrawMeshTasksIndirectNV = 0;
   PFN_vkCmdDrawMeshTasksNV vkCmdDrawMeshTasksNV = 0;
@@ -120093,16 +122860,16 @@
   PFN_vkCmdEndQuery vkCmdEndQuery = 0;
   PFN_vkCmdEndQueryIndexedEXT vkCmdEndQueryIndexedEXT = 0;
   PFN_vkCmdEndRenderPass vkCmdEndRenderPass = 0;
-  PFN_vkCmdEndRenderPass2KHR vkCmdEndRenderPass2KHR = 0;
   PFN_vkCmdEndRenderPass2 vkCmdEndRenderPass2 = 0;
+  PFN_vkCmdEndRenderPass2KHR vkCmdEndRenderPass2KHR = 0;
   PFN_vkCmdEndTransformFeedbackEXT vkCmdEndTransformFeedbackEXT = 0;
   PFN_vkCmdExecuteCommands vkCmdExecuteCommands = 0;
   PFN_vkCmdExecuteGeneratedCommandsNV vkCmdExecuteGeneratedCommandsNV = 0;
   PFN_vkCmdFillBuffer vkCmdFillBuffer = 0;
   PFN_vkCmdInsertDebugUtilsLabelEXT vkCmdInsertDebugUtilsLabelEXT = 0;
   PFN_vkCmdNextSubpass vkCmdNextSubpass = 0;
-  PFN_vkCmdNextSubpass2KHR vkCmdNextSubpass2KHR = 0;
   PFN_vkCmdNextSubpass2 vkCmdNextSubpass2 = 0;
+  PFN_vkCmdNextSubpass2KHR vkCmdNextSubpass2KHR = 0;
   PFN_vkCmdPipelineBarrier vkCmdPipelineBarrier = 0;
   PFN_vkCmdPipelineBarrier2KHR vkCmdPipelineBarrier2KHR = 0;
   PFN_vkCmdPreprocessGeneratedCommandsNV vkCmdPreprocessGeneratedCommandsNV = 0;
@@ -120125,8 +122892,8 @@
   PFN_vkCmdSetDepthCompareOpEXT vkCmdSetDepthCompareOpEXT = 0;
   PFN_vkCmdSetDepthTestEnableEXT vkCmdSetDepthTestEnableEXT = 0;
   PFN_vkCmdSetDepthWriteEnableEXT vkCmdSetDepthWriteEnableEXT = 0;
-  PFN_vkCmdSetDeviceMaskKHR vkCmdSetDeviceMaskKHR = 0;
   PFN_vkCmdSetDeviceMask vkCmdSetDeviceMask = 0;
+  PFN_vkCmdSetDeviceMaskKHR vkCmdSetDeviceMaskKHR = 0;
   PFN_vkCmdSetDiscardRectangleEXT vkCmdSetDiscardRectangleEXT = 0;
   PFN_vkCmdSetEvent vkCmdSetEvent = 0;
   PFN_vkCmdSetEvent2KHR vkCmdSetEvent2KHR = 0;
@@ -120189,6 +122956,11 @@
 #else
   PFN_dummy placeholder_dont_call_vkCreateBufferCollectionFUCHSIA = 0;
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+  PFN_vkCreateBufferCollectionFUCHSIAX vkCreateBufferCollectionFUCHSIAX = 0;
+#else
+  PFN_dummy placeholder_dont_call_vkCreateBufferCollectionFUCHSIAX = 0;
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
   PFN_vkCreateBufferView vkCreateBufferView = 0;
   PFN_vkCreateCommandPool vkCreateCommandPool = 0;
   PFN_vkCreateComputePipelines vkCreateComputePipelines = 0;
@@ -120197,9 +122969,9 @@
   PFN_vkCreateDeferredOperationKHR vkCreateDeferredOperationKHR = 0;
   PFN_vkCreateDescriptorPool vkCreateDescriptorPool = 0;
   PFN_vkCreateDescriptorSetLayout vkCreateDescriptorSetLayout = 0;
+  PFN_vkCreateDescriptorUpdateTemplate vkCreateDescriptorUpdateTemplate = 0;
   PFN_vkCreateDescriptorUpdateTemplateKHR vkCreateDescriptorUpdateTemplateKHR =
       0;
-  PFN_vkCreateDescriptorUpdateTemplate vkCreateDescriptorUpdateTemplate = 0;
   PFN_vkCreateDevice vkCreateDevice = 0;
 #if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
   PFN_vkCreateDirectFBSurfaceEXT vkCreateDirectFBSurfaceEXT = 0;
@@ -120244,11 +123016,11 @@
   PFN_vkCreateRayTracingPipelinesKHR vkCreateRayTracingPipelinesKHR = 0;
   PFN_vkCreateRayTracingPipelinesNV vkCreateRayTracingPipelinesNV = 0;
   PFN_vkCreateRenderPass vkCreateRenderPass = 0;
-  PFN_vkCreateRenderPass2KHR vkCreateRenderPass2KHR = 0;
   PFN_vkCreateRenderPass2 vkCreateRenderPass2 = 0;
+  PFN_vkCreateRenderPass2KHR vkCreateRenderPass2KHR = 0;
   PFN_vkCreateSampler vkCreateSampler = 0;
-  PFN_vkCreateSamplerYcbcrConversionKHR vkCreateSamplerYcbcrConversionKHR = 0;
   PFN_vkCreateSamplerYcbcrConversion vkCreateSamplerYcbcrConversion = 0;
+  PFN_vkCreateSamplerYcbcrConversionKHR vkCreateSamplerYcbcrConversionKHR = 0;
 #if defined(VK_USE_PLATFORM_SCREEN_QNX)
   PFN_vkCreateScreenSurfaceQNX vkCreateScreenSurfaceQNX = 0;
 #else
@@ -120301,6 +123073,11 @@
 #else
   PFN_dummy placeholder_dont_call_vkDestroyBufferCollectionFUCHSIA = 0;
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+  PFN_vkDestroyBufferCollectionFUCHSIAX vkDestroyBufferCollectionFUCHSIAX = 0;
+#else
+  PFN_dummy placeholder_dont_call_vkDestroyBufferCollectionFUCHSIAX = 0;
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
   PFN_vkDestroyBufferView vkDestroyBufferView = 0;
   PFN_vkDestroyCommandPool vkDestroyCommandPool = 0;
   PFN_vkDestroyDebugReportCallbackEXT vkDestroyDebugReportCallbackEXT = 0;
@@ -120308,9 +123085,9 @@
   PFN_vkDestroyDeferredOperationKHR vkDestroyDeferredOperationKHR = 0;
   PFN_vkDestroyDescriptorPool vkDestroyDescriptorPool = 0;
   PFN_vkDestroyDescriptorSetLayout vkDestroyDescriptorSetLayout = 0;
+  PFN_vkDestroyDescriptorUpdateTemplate vkDestroyDescriptorUpdateTemplate = 0;
   PFN_vkDestroyDescriptorUpdateTemplateKHR
       vkDestroyDescriptorUpdateTemplateKHR = 0;
-  PFN_vkDestroyDescriptorUpdateTemplate vkDestroyDescriptorUpdateTemplate = 0;
   PFN_vkDestroyDevice vkDestroyDevice = 0;
   PFN_vkDestroyEvent vkDestroyEvent = 0;
   PFN_vkDestroyFence vkDestroyFence = 0;
@@ -120326,8 +123103,8 @@
   PFN_vkDestroyQueryPool vkDestroyQueryPool = 0;
   PFN_vkDestroyRenderPass vkDestroyRenderPass = 0;
   PFN_vkDestroySampler vkDestroySampler = 0;
-  PFN_vkDestroySamplerYcbcrConversionKHR vkDestroySamplerYcbcrConversionKHR = 0;
   PFN_vkDestroySamplerYcbcrConversion vkDestroySamplerYcbcrConversion = 0;
+  PFN_vkDestroySamplerYcbcrConversionKHR vkDestroySamplerYcbcrConversionKHR = 0;
   PFN_vkDestroySemaphore vkDestroySemaphore = 0;
   PFN_vkDestroyShaderModule vkDestroyShaderModule = 0;
   PFN_vkDestroySurfaceKHR vkDestroySurfaceKHR = 0;
@@ -120343,8 +123120,8 @@
       vkEnumerateInstanceExtensionProperties = 0;
   PFN_vkEnumerateInstanceLayerProperties vkEnumerateInstanceLayerProperties = 0;
   PFN_vkEnumerateInstanceVersion vkEnumerateInstanceVersion = 0;
-  PFN_vkEnumeratePhysicalDeviceGroupsKHR vkEnumeratePhysicalDeviceGroupsKHR = 0;
   PFN_vkEnumeratePhysicalDeviceGroups vkEnumeratePhysicalDeviceGroups = 0;
+  PFN_vkEnumeratePhysicalDeviceGroupsKHR vkEnumeratePhysicalDeviceGroupsKHR = 0;
   PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR
       vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = 0;
   PFN_vkEnumeratePhysicalDevices vkEnumeratePhysicalDevices = 0;
@@ -120373,30 +123150,42 @@
   PFN_dummy placeholder_dont_call_vkGetBufferCollectionProperties2FUCHSIA = 0;
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 #if defined(VK_USE_PLATFORM_FUCHSIA)
+  PFN_vkGetBufferCollectionProperties2FUCHSIAX
+      vkGetBufferCollectionProperties2FUCHSIAX = 0;
+#else
+  PFN_dummy placeholder_dont_call_vkGetBufferCollectionProperties2FUCHSIAX = 0;
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+#if defined(VK_USE_PLATFORM_FUCHSIA)
   PFN_vkGetBufferCollectionPropertiesFUCHSIA
       vkGetBufferCollectionPropertiesFUCHSIA = 0;
 #else
   PFN_dummy placeholder_dont_call_vkGetBufferCollectionPropertiesFUCHSIA = 0;
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+  PFN_vkGetBufferCollectionPropertiesFUCHSIAX
+      vkGetBufferCollectionPropertiesFUCHSIAX = 0;
+#else
+  PFN_dummy placeholder_dont_call_vkGetBufferCollectionPropertiesFUCHSIAX = 0;
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+  PFN_vkGetBufferDeviceAddress vkGetBufferDeviceAddress = 0;
   PFN_vkGetBufferDeviceAddressEXT vkGetBufferDeviceAddressEXT = 0;
   PFN_vkGetBufferDeviceAddressKHR vkGetBufferDeviceAddressKHR = 0;
-  PFN_vkGetBufferDeviceAddress vkGetBufferDeviceAddress = 0;
   PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements = 0;
-  PFN_vkGetBufferMemoryRequirements2KHR vkGetBufferMemoryRequirements2KHR = 0;
   PFN_vkGetBufferMemoryRequirements2 vkGetBufferMemoryRequirements2 = 0;
-  PFN_vkGetBufferOpaqueCaptureAddressKHR vkGetBufferOpaqueCaptureAddressKHR = 0;
+  PFN_vkGetBufferMemoryRequirements2KHR vkGetBufferMemoryRequirements2KHR = 0;
   PFN_vkGetBufferOpaqueCaptureAddress vkGetBufferOpaqueCaptureAddress = 0;
+  PFN_vkGetBufferOpaqueCaptureAddressKHR vkGetBufferOpaqueCaptureAddressKHR = 0;
   PFN_vkGetCalibratedTimestampsEXT vkGetCalibratedTimestampsEXT = 0;
   PFN_vkGetDeferredOperationMaxConcurrencyKHR
       vkGetDeferredOperationMaxConcurrencyKHR = 0;
   PFN_vkGetDeferredOperationResultKHR vkGetDeferredOperationResultKHR = 0;
-  PFN_vkGetDescriptorSetLayoutSupportKHR vkGetDescriptorSetLayoutSupportKHR = 0;
   PFN_vkGetDescriptorSetLayoutSupport vkGetDescriptorSetLayoutSupport = 0;
+  PFN_vkGetDescriptorSetLayoutSupportKHR vkGetDescriptorSetLayoutSupportKHR = 0;
   PFN_vkGetDeviceAccelerationStructureCompatibilityKHR
       vkGetDeviceAccelerationStructureCompatibilityKHR = 0;
+  PFN_vkGetDeviceGroupPeerMemoryFeatures vkGetDeviceGroupPeerMemoryFeatures = 0;
   PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR
       vkGetDeviceGroupPeerMemoryFeaturesKHR = 0;
-  PFN_vkGetDeviceGroupPeerMemoryFeatures vkGetDeviceGroupPeerMemoryFeatures = 0;
   PFN_vkGetDeviceGroupPresentCapabilitiesKHR
       vkGetDeviceGroupPresentCapabilitiesKHR = 0;
 #if defined(VK_USE_PLATFORM_WIN32_KHR)
@@ -120408,10 +123197,10 @@
   PFN_vkGetDeviceGroupSurfacePresentModesKHR
       vkGetDeviceGroupSurfacePresentModesKHR = 0;
   PFN_vkGetDeviceMemoryCommitment vkGetDeviceMemoryCommitment = 0;
-  PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR
-      vkGetDeviceMemoryOpaqueCaptureAddressKHR = 0;
   PFN_vkGetDeviceMemoryOpaqueCaptureAddress
       vkGetDeviceMemoryOpaqueCaptureAddress = 0;
+  PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR
+      vkGetDeviceMemoryOpaqueCaptureAddressKHR = 0;
   PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr = 0;
   PFN_vkGetDeviceQueue vkGetDeviceQueue = 0;
   PFN_vkGetDeviceQueue2 vkGetDeviceQueue2 = 0;
@@ -120434,13 +123223,13 @@
   PFN_vkGetImageDrmFormatModifierPropertiesEXT
       vkGetImageDrmFormatModifierPropertiesEXT = 0;
   PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements = 0;
-  PFN_vkGetImageMemoryRequirements2KHR vkGetImageMemoryRequirements2KHR = 0;
   PFN_vkGetImageMemoryRequirements2 vkGetImageMemoryRequirements2 = 0;
+  PFN_vkGetImageMemoryRequirements2KHR vkGetImageMemoryRequirements2KHR = 0;
   PFN_vkGetImageSparseMemoryRequirements vkGetImageSparseMemoryRequirements = 0;
-  PFN_vkGetImageSparseMemoryRequirements2KHR
-      vkGetImageSparseMemoryRequirements2KHR = 0;
   PFN_vkGetImageSparseMemoryRequirements2 vkGetImageSparseMemoryRequirements2 =
       0;
+  PFN_vkGetImageSparseMemoryRequirements2KHR
+      vkGetImageSparseMemoryRequirements2KHR = 0;
   PFN_vkGetImageSubresourceLayout vkGetImageSubresourceLayout = 0;
   PFN_vkGetImageViewAddressNVX vkGetImageViewAddressNVX = 0;
   PFN_vkGetImageViewHandleNVX vkGetImageViewHandleNVX = 0;
@@ -120504,58 +123293,58 @@
       vkGetPhysicalDeviceDisplayProperties2KHR = 0;
   PFN_vkGetPhysicalDeviceDisplayPropertiesKHR
       vkGetPhysicalDeviceDisplayPropertiesKHR = 0;
-  PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR
-      vkGetPhysicalDeviceExternalBufferPropertiesKHR = 0;
   PFN_vkGetPhysicalDeviceExternalBufferProperties
       vkGetPhysicalDeviceExternalBufferProperties = 0;
-  PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR
-      vkGetPhysicalDeviceExternalFencePropertiesKHR = 0;
+  PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR
+      vkGetPhysicalDeviceExternalBufferPropertiesKHR = 0;
   PFN_vkGetPhysicalDeviceExternalFenceProperties
       vkGetPhysicalDeviceExternalFenceProperties = 0;
+  PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR
+      vkGetPhysicalDeviceExternalFencePropertiesKHR = 0;
   PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV
       vkGetPhysicalDeviceExternalImageFormatPropertiesNV = 0;
-  PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR
-      vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = 0;
   PFN_vkGetPhysicalDeviceExternalSemaphoreProperties
       vkGetPhysicalDeviceExternalSemaphoreProperties = 0;
+  PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR
+      vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = 0;
   PFN_vkGetPhysicalDeviceFeatures vkGetPhysicalDeviceFeatures = 0;
-  PFN_vkGetPhysicalDeviceFeatures2KHR vkGetPhysicalDeviceFeatures2KHR = 0;
   PFN_vkGetPhysicalDeviceFeatures2 vkGetPhysicalDeviceFeatures2 = 0;
+  PFN_vkGetPhysicalDeviceFeatures2KHR vkGetPhysicalDeviceFeatures2KHR = 0;
   PFN_vkGetPhysicalDeviceFormatProperties vkGetPhysicalDeviceFormatProperties =
       0;
-  PFN_vkGetPhysicalDeviceFormatProperties2KHR
-      vkGetPhysicalDeviceFormatProperties2KHR = 0;
   PFN_vkGetPhysicalDeviceFormatProperties2
       vkGetPhysicalDeviceFormatProperties2 = 0;
+  PFN_vkGetPhysicalDeviceFormatProperties2KHR
+      vkGetPhysicalDeviceFormatProperties2KHR = 0;
   PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR
       vkGetPhysicalDeviceFragmentShadingRatesKHR = 0;
   PFN_vkGetPhysicalDeviceImageFormatProperties
       vkGetPhysicalDeviceImageFormatProperties = 0;
-  PFN_vkGetPhysicalDeviceImageFormatProperties2KHR
-      vkGetPhysicalDeviceImageFormatProperties2KHR = 0;
   PFN_vkGetPhysicalDeviceImageFormatProperties2
       vkGetPhysicalDeviceImageFormatProperties2 = 0;
+  PFN_vkGetPhysicalDeviceImageFormatProperties2KHR
+      vkGetPhysicalDeviceImageFormatProperties2KHR = 0;
   PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties =
       0;
-  PFN_vkGetPhysicalDeviceMemoryProperties2KHR
-      vkGetPhysicalDeviceMemoryProperties2KHR = 0;
   PFN_vkGetPhysicalDeviceMemoryProperties2
       vkGetPhysicalDeviceMemoryProperties2 = 0;
+  PFN_vkGetPhysicalDeviceMemoryProperties2KHR
+      vkGetPhysicalDeviceMemoryProperties2KHR = 0;
   PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT
       vkGetPhysicalDeviceMultisamplePropertiesEXT = 0;
   PFN_vkGetPhysicalDevicePresentRectanglesKHR
       vkGetPhysicalDevicePresentRectanglesKHR = 0;
   PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties = 0;
-  PFN_vkGetPhysicalDeviceProperties2KHR vkGetPhysicalDeviceProperties2KHR = 0;
   PFN_vkGetPhysicalDeviceProperties2 vkGetPhysicalDeviceProperties2 = 0;
+  PFN_vkGetPhysicalDeviceProperties2KHR vkGetPhysicalDeviceProperties2KHR = 0;
   PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR
       vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = 0;
   PFN_vkGetPhysicalDeviceQueueFamilyProperties
       vkGetPhysicalDeviceQueueFamilyProperties = 0;
-  PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR
-      vkGetPhysicalDeviceQueueFamilyProperties2KHR = 0;
   PFN_vkGetPhysicalDeviceQueueFamilyProperties2
       vkGetPhysicalDeviceQueueFamilyProperties2 = 0;
+  PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR
+      vkGetPhysicalDeviceQueueFamilyProperties2KHR = 0;
 #if defined(VK_USE_PLATFORM_SCREEN_QNX)
   PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX
       vkGetPhysicalDeviceScreenPresentationSupportQNX = 0;
@@ -120565,10 +123354,10 @@
 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
   PFN_vkGetPhysicalDeviceSparseImageFormatProperties
       vkGetPhysicalDeviceSparseImageFormatProperties = 0;
-  PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR
-      vkGetPhysicalDeviceSparseImageFormatProperties2KHR = 0;
   PFN_vkGetPhysicalDeviceSparseImageFormatProperties2
       vkGetPhysicalDeviceSparseImageFormatProperties2 = 0;
+  PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR
+      vkGetPhysicalDeviceSparseImageFormatProperties2KHR = 0;
   PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV
       vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = 0;
   PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT
@@ -120641,16 +123430,16 @@
 #endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
   PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR
       vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = 0;
-  PFN_vkGetRayTracingShaderGroupHandlesNV vkGetRayTracingShaderGroupHandlesNV =
-      0;
   PFN_vkGetRayTracingShaderGroupHandlesKHR
       vkGetRayTracingShaderGroupHandlesKHR = 0;
+  PFN_vkGetRayTracingShaderGroupHandlesNV vkGetRayTracingShaderGroupHandlesNV =
+      0;
   PFN_vkGetRayTracingShaderGroupStackSizeKHR
       vkGetRayTracingShaderGroupStackSizeKHR = 0;
   PFN_vkGetRefreshCycleDurationGOOGLE vkGetRefreshCycleDurationGOOGLE = 0;
   PFN_vkGetRenderAreaGranularity vkGetRenderAreaGranularity = 0;
-  PFN_vkGetSemaphoreCounterValueKHR vkGetSemaphoreCounterValueKHR = 0;
   PFN_vkGetSemaphoreCounterValue vkGetSemaphoreCounterValue = 0;
+  PFN_vkGetSemaphoreCounterValueKHR vkGetSemaphoreCounterValueKHR = 0;
   PFN_vkGetSemaphoreFdKHR vkGetSemaphoreFdKHR = 0;
 #if defined(VK_USE_PLATFORM_WIN32_KHR)
   PFN_vkGetSemaphoreWin32HandleKHR vkGetSemaphoreWin32HandleKHR = 0;
@@ -120727,8 +123516,8 @@
   PFN_vkResetDescriptorPool vkResetDescriptorPool = 0;
   PFN_vkResetEvent vkResetEvent = 0;
   PFN_vkResetFences vkResetFences = 0;
-  PFN_vkResetQueryPoolEXT vkResetQueryPoolEXT = 0;
   PFN_vkResetQueryPool vkResetQueryPool = 0;
+  PFN_vkResetQueryPoolEXT vkResetQueryPoolEXT = 0;
 #if defined(VK_USE_PLATFORM_FUCHSIA)
   PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA
       vkSetBufferCollectionBufferConstraintsFUCHSIA = 0;
@@ -120737,29 +123526,49 @@
       placeholder_dont_call_vkSetBufferCollectionBufferConstraintsFUCHSIA = 0;
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 #if defined(VK_USE_PLATFORM_FUCHSIA)
+  PFN_vkSetBufferCollectionBufferConstraintsFUCHSIAX
+      vkSetBufferCollectionBufferConstraintsFUCHSIAX = 0;
+#else
+  PFN_dummy
+      placeholder_dont_call_vkSetBufferCollectionBufferConstraintsFUCHSIAX = 0;
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+#if defined(VK_USE_PLATFORM_FUCHSIA)
   PFN_vkSetBufferCollectionConstraintsFUCHSIA
       vkSetBufferCollectionConstraintsFUCHSIA = 0;
 #else
   PFN_dummy placeholder_dont_call_vkSetBufferCollectionConstraintsFUCHSIA = 0;
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 #if defined(VK_USE_PLATFORM_FUCHSIA)
+  PFN_vkSetBufferCollectionConstraintsFUCHSIAX
+      vkSetBufferCollectionConstraintsFUCHSIAX = 0;
+#else
+  PFN_dummy placeholder_dont_call_vkSetBufferCollectionConstraintsFUCHSIAX = 0;
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+#if defined(VK_USE_PLATFORM_FUCHSIA)
   PFN_vkSetBufferCollectionImageConstraintsFUCHSIA
       vkSetBufferCollectionImageConstraintsFUCHSIA = 0;
 #else
   PFN_dummy placeholder_dont_call_vkSetBufferCollectionImageConstraintsFUCHSIA =
       0;
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+  PFN_vkSetBufferCollectionImageConstraintsFUCHSIAX
+      vkSetBufferCollectionImageConstraintsFUCHSIAX = 0;
+#else
+  PFN_dummy
+      placeholder_dont_call_vkSetBufferCollectionImageConstraintsFUCHSIAX = 0;
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
   PFN_vkSetDebugUtilsObjectNameEXT vkSetDebugUtilsObjectNameEXT = 0;
   PFN_vkSetDebugUtilsObjectTagEXT vkSetDebugUtilsObjectTagEXT = 0;
   PFN_vkSetEvent vkSetEvent = 0;
   PFN_vkSetHdrMetadataEXT vkSetHdrMetadataEXT = 0;
   PFN_vkSetLocalDimmingAMD vkSetLocalDimmingAMD = 0;
   PFN_vkSetPrivateDataEXT vkSetPrivateDataEXT = 0;
-  PFN_vkSignalSemaphoreKHR vkSignalSemaphoreKHR = 0;
   PFN_vkSignalSemaphore vkSignalSemaphore = 0;
+  PFN_vkSignalSemaphoreKHR vkSignalSemaphoreKHR = 0;
   PFN_vkSubmitDebugUtilsMessageEXT vkSubmitDebugUtilsMessageEXT = 0;
-  PFN_vkTrimCommandPoolKHR vkTrimCommandPoolKHR = 0;
   PFN_vkTrimCommandPool vkTrimCommandPool = 0;
+  PFN_vkTrimCommandPoolKHR vkTrimCommandPoolKHR = 0;
 #if defined(VK_USE_PLATFORM_FUCHSIA)
   PFN_vkTrimCompactImageDeviceMemoryFUCHSIA
       vkTrimCompactImageDeviceMemoryFUCHSIA = 0;
@@ -120768,13 +123577,13 @@
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
   PFN_vkUninitializePerformanceApiINTEL vkUninitializePerformanceApiINTEL = 0;
   PFN_vkUnmapMemory vkUnmapMemory = 0;
+  PFN_vkUpdateDescriptorSetWithTemplate vkUpdateDescriptorSetWithTemplate = 0;
   PFN_vkUpdateDescriptorSetWithTemplateKHR
       vkUpdateDescriptorSetWithTemplateKHR = 0;
-  PFN_vkUpdateDescriptorSetWithTemplate vkUpdateDescriptorSetWithTemplate = 0;
   PFN_vkUpdateDescriptorSets vkUpdateDescriptorSets = 0;
   PFN_vkWaitForFences vkWaitForFences = 0;
-  PFN_vkWaitSemaphoresKHR vkWaitSemaphoresKHR = 0;
   PFN_vkWaitSemaphores vkWaitSemaphores = 0;
+  PFN_vkWaitSemaphoresKHR vkWaitSemaphoresKHR = 0;
   PFN_vkWriteAccelerationStructuresPropertiesKHR
       vkWriteAccelerationStructuresPropertiesKHR = 0;
 
@@ -120944,10 +123753,10 @@
             instance, "vkEnumerateDeviceExtensionProperties"));
     vkEnumerateDeviceLayerProperties = PFN_vkEnumerateDeviceLayerProperties(
         vkGetInstanceProcAddr(instance, "vkEnumerateDeviceLayerProperties"));
-    vkEnumeratePhysicalDeviceGroupsKHR = PFN_vkEnumeratePhysicalDeviceGroupsKHR(
-        vkGetInstanceProcAddr(instance, "vkEnumeratePhysicalDeviceGroupsKHR"));
     vkEnumeratePhysicalDeviceGroups = PFN_vkEnumeratePhysicalDeviceGroups(
         vkGetInstanceProcAddr(instance, "vkEnumeratePhysicalDeviceGroups"));
+    vkEnumeratePhysicalDeviceGroupsKHR = PFN_vkEnumeratePhysicalDeviceGroupsKHR(
+        vkGetInstanceProcAddr(instance, "vkEnumeratePhysicalDeviceGroupsKHR"));
     if (!vkEnumeratePhysicalDeviceGroups)
       vkEnumeratePhysicalDeviceGroups = vkEnumeratePhysicalDeviceGroupsKHR;
     vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR =
@@ -120995,22 +123804,22 @@
     vkGetPhysicalDeviceDisplayPropertiesKHR =
         PFN_vkGetPhysicalDeviceDisplayPropertiesKHR(vkGetInstanceProcAddr(
             instance, "vkGetPhysicalDeviceDisplayPropertiesKHR"));
+    vkGetPhysicalDeviceExternalBufferProperties =
+        PFN_vkGetPhysicalDeviceExternalBufferProperties(vkGetInstanceProcAddr(
+            instance, "vkGetPhysicalDeviceExternalBufferProperties"));
     vkGetPhysicalDeviceExternalBufferPropertiesKHR =
         PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR(
             vkGetInstanceProcAddr(
                 instance, "vkGetPhysicalDeviceExternalBufferPropertiesKHR"));
-    vkGetPhysicalDeviceExternalBufferProperties =
-        PFN_vkGetPhysicalDeviceExternalBufferProperties(vkGetInstanceProcAddr(
-            instance, "vkGetPhysicalDeviceExternalBufferProperties"));
     if (!vkGetPhysicalDeviceExternalBufferProperties)
       vkGetPhysicalDeviceExternalBufferProperties =
           vkGetPhysicalDeviceExternalBufferPropertiesKHR;
-    vkGetPhysicalDeviceExternalFencePropertiesKHR =
-        PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR(vkGetInstanceProcAddr(
-            instance, "vkGetPhysicalDeviceExternalFencePropertiesKHR"));
     vkGetPhysicalDeviceExternalFenceProperties =
         PFN_vkGetPhysicalDeviceExternalFenceProperties(vkGetInstanceProcAddr(
             instance, "vkGetPhysicalDeviceExternalFenceProperties"));
+    vkGetPhysicalDeviceExternalFencePropertiesKHR =
+        PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR(vkGetInstanceProcAddr(
+            instance, "vkGetPhysicalDeviceExternalFencePropertiesKHR"));
     if (!vkGetPhysicalDeviceExternalFenceProperties)
       vkGetPhysicalDeviceExternalFenceProperties =
           vkGetPhysicalDeviceExternalFencePropertiesKHR;
@@ -121019,34 +123828,34 @@
             vkGetInstanceProcAddr(
                 instance,
                 "vkGetPhysicalDeviceExternalImageFormatPropertiesNV"));
-    vkGetPhysicalDeviceExternalSemaphorePropertiesKHR =
-        PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
-            vkGetInstanceProcAddr(
-                instance, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR"));
     vkGetPhysicalDeviceExternalSemaphoreProperties =
         PFN_vkGetPhysicalDeviceExternalSemaphoreProperties(
             vkGetInstanceProcAddr(
                 instance, "vkGetPhysicalDeviceExternalSemaphoreProperties"));
+    vkGetPhysicalDeviceExternalSemaphorePropertiesKHR =
+        PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
+            vkGetInstanceProcAddr(
+                instance, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR"));
     if (!vkGetPhysicalDeviceExternalSemaphoreProperties)
       vkGetPhysicalDeviceExternalSemaphoreProperties =
           vkGetPhysicalDeviceExternalSemaphorePropertiesKHR;
     vkGetPhysicalDeviceFeatures = PFN_vkGetPhysicalDeviceFeatures(
         vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceFeatures"));
-    vkGetPhysicalDeviceFeatures2KHR = PFN_vkGetPhysicalDeviceFeatures2KHR(
-        vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceFeatures2KHR"));
     vkGetPhysicalDeviceFeatures2 = PFN_vkGetPhysicalDeviceFeatures2(
         vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceFeatures2"));
+    vkGetPhysicalDeviceFeatures2KHR = PFN_vkGetPhysicalDeviceFeatures2KHR(
+        vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceFeatures2KHR"));
     if (!vkGetPhysicalDeviceFeatures2)
       vkGetPhysicalDeviceFeatures2 = vkGetPhysicalDeviceFeatures2KHR;
     vkGetPhysicalDeviceFormatProperties =
         PFN_vkGetPhysicalDeviceFormatProperties(vkGetInstanceProcAddr(
             instance, "vkGetPhysicalDeviceFormatProperties"));
-    vkGetPhysicalDeviceFormatProperties2KHR =
-        PFN_vkGetPhysicalDeviceFormatProperties2KHR(vkGetInstanceProcAddr(
-            instance, "vkGetPhysicalDeviceFormatProperties2KHR"));
     vkGetPhysicalDeviceFormatProperties2 =
         PFN_vkGetPhysicalDeviceFormatProperties2(vkGetInstanceProcAddr(
             instance, "vkGetPhysicalDeviceFormatProperties2"));
+    vkGetPhysicalDeviceFormatProperties2KHR =
+        PFN_vkGetPhysicalDeviceFormatProperties2KHR(vkGetInstanceProcAddr(
+            instance, "vkGetPhysicalDeviceFormatProperties2KHR"));
     if (!vkGetPhysicalDeviceFormatProperties2)
       vkGetPhysicalDeviceFormatProperties2 =
           vkGetPhysicalDeviceFormatProperties2KHR;
@@ -121056,24 +123865,24 @@
     vkGetPhysicalDeviceImageFormatProperties =
         PFN_vkGetPhysicalDeviceImageFormatProperties(vkGetInstanceProcAddr(
             instance, "vkGetPhysicalDeviceImageFormatProperties"));
-    vkGetPhysicalDeviceImageFormatProperties2KHR =
-        PFN_vkGetPhysicalDeviceImageFormatProperties2KHR(vkGetInstanceProcAddr(
-            instance, "vkGetPhysicalDeviceImageFormatProperties2KHR"));
     vkGetPhysicalDeviceImageFormatProperties2 =
         PFN_vkGetPhysicalDeviceImageFormatProperties2(vkGetInstanceProcAddr(
             instance, "vkGetPhysicalDeviceImageFormatProperties2"));
+    vkGetPhysicalDeviceImageFormatProperties2KHR =
+        PFN_vkGetPhysicalDeviceImageFormatProperties2KHR(vkGetInstanceProcAddr(
+            instance, "vkGetPhysicalDeviceImageFormatProperties2KHR"));
     if (!vkGetPhysicalDeviceImageFormatProperties2)
       vkGetPhysicalDeviceImageFormatProperties2 =
           vkGetPhysicalDeviceImageFormatProperties2KHR;
     vkGetPhysicalDeviceMemoryProperties =
         PFN_vkGetPhysicalDeviceMemoryProperties(vkGetInstanceProcAddr(
             instance, "vkGetPhysicalDeviceMemoryProperties"));
-    vkGetPhysicalDeviceMemoryProperties2KHR =
-        PFN_vkGetPhysicalDeviceMemoryProperties2KHR(vkGetInstanceProcAddr(
-            instance, "vkGetPhysicalDeviceMemoryProperties2KHR"));
     vkGetPhysicalDeviceMemoryProperties2 =
         PFN_vkGetPhysicalDeviceMemoryProperties2(vkGetInstanceProcAddr(
             instance, "vkGetPhysicalDeviceMemoryProperties2"));
+    vkGetPhysicalDeviceMemoryProperties2KHR =
+        PFN_vkGetPhysicalDeviceMemoryProperties2KHR(vkGetInstanceProcAddr(
+            instance, "vkGetPhysicalDeviceMemoryProperties2KHR"));
     if (!vkGetPhysicalDeviceMemoryProperties2)
       vkGetPhysicalDeviceMemoryProperties2 =
           vkGetPhysicalDeviceMemoryProperties2KHR;
@@ -121085,10 +123894,10 @@
             instance, "vkGetPhysicalDevicePresentRectanglesKHR"));
     vkGetPhysicalDeviceProperties = PFN_vkGetPhysicalDeviceProperties(
         vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceProperties"));
-    vkGetPhysicalDeviceProperties2KHR = PFN_vkGetPhysicalDeviceProperties2KHR(
-        vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceProperties2KHR"));
     vkGetPhysicalDeviceProperties2 = PFN_vkGetPhysicalDeviceProperties2(
         vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceProperties2"));
+    vkGetPhysicalDeviceProperties2KHR = PFN_vkGetPhysicalDeviceProperties2KHR(
+        vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceProperties2KHR"));
     if (!vkGetPhysicalDeviceProperties2)
       vkGetPhysicalDeviceProperties2 = vkGetPhysicalDeviceProperties2KHR;
     vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR =
@@ -121099,12 +123908,12 @@
     vkGetPhysicalDeviceQueueFamilyProperties =
         PFN_vkGetPhysicalDeviceQueueFamilyProperties(vkGetInstanceProcAddr(
             instance, "vkGetPhysicalDeviceQueueFamilyProperties"));
-    vkGetPhysicalDeviceQueueFamilyProperties2KHR =
-        PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR(vkGetInstanceProcAddr(
-            instance, "vkGetPhysicalDeviceQueueFamilyProperties2KHR"));
     vkGetPhysicalDeviceQueueFamilyProperties2 =
         PFN_vkGetPhysicalDeviceQueueFamilyProperties2(vkGetInstanceProcAddr(
             instance, "vkGetPhysicalDeviceQueueFamilyProperties2"));
+    vkGetPhysicalDeviceQueueFamilyProperties2KHR =
+        PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR(vkGetInstanceProcAddr(
+            instance, "vkGetPhysicalDeviceQueueFamilyProperties2KHR"));
     if (!vkGetPhysicalDeviceQueueFamilyProperties2)
       vkGetPhysicalDeviceQueueFamilyProperties2 =
           vkGetPhysicalDeviceQueueFamilyProperties2KHR;
@@ -121118,15 +123927,15 @@
         PFN_vkGetPhysicalDeviceSparseImageFormatProperties(
             vkGetInstanceProcAddr(
                 instance, "vkGetPhysicalDeviceSparseImageFormatProperties"));
+    vkGetPhysicalDeviceSparseImageFormatProperties2 =
+        PFN_vkGetPhysicalDeviceSparseImageFormatProperties2(
+            vkGetInstanceProcAddr(
+                instance, "vkGetPhysicalDeviceSparseImageFormatProperties2"));
     vkGetPhysicalDeviceSparseImageFormatProperties2KHR =
         PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
             vkGetInstanceProcAddr(
                 instance,
                 "vkGetPhysicalDeviceSparseImageFormatProperties2KHR"));
-    vkGetPhysicalDeviceSparseImageFormatProperties2 =
-        PFN_vkGetPhysicalDeviceSparseImageFormatProperties2(
-            vkGetInstanceProcAddr(
-                instance, "vkGetPhysicalDeviceSparseImageFormatProperties2"));
     if (!vkGetPhysicalDeviceSparseImageFormatProperties2)
       vkGetPhysicalDeviceSparseImageFormatProperties2 =
           vkGetPhysicalDeviceSparseImageFormatProperties2KHR;
@@ -121224,18 +124033,18 @@
             instance, "vkBindAccelerationStructureMemoryNV"));
     vkBindBufferMemory = PFN_vkBindBufferMemory(
         vkGetInstanceProcAddr(instance, "vkBindBufferMemory"));
-    vkBindBufferMemory2KHR = PFN_vkBindBufferMemory2KHR(
-        vkGetInstanceProcAddr(instance, "vkBindBufferMemory2KHR"));
     vkBindBufferMemory2 = PFN_vkBindBufferMemory2(
         vkGetInstanceProcAddr(instance, "vkBindBufferMemory2"));
+    vkBindBufferMemory2KHR = PFN_vkBindBufferMemory2KHR(
+        vkGetInstanceProcAddr(instance, "vkBindBufferMemory2KHR"));
     if (!vkBindBufferMemory2)
       vkBindBufferMemory2 = vkBindBufferMemory2KHR;
     vkBindImageMemory = PFN_vkBindImageMemory(
         vkGetInstanceProcAddr(instance, "vkBindImageMemory"));
-    vkBindImageMemory2KHR = PFN_vkBindImageMemory2KHR(
-        vkGetInstanceProcAddr(instance, "vkBindImageMemory2KHR"));
     vkBindImageMemory2 = PFN_vkBindImageMemory2(
         vkGetInstanceProcAddr(instance, "vkBindImageMemory2"));
+    vkBindImageMemory2KHR = PFN_vkBindImageMemory2KHR(
+        vkGetInstanceProcAddr(instance, "vkBindImageMemory2KHR"));
     if (!vkBindImageMemory2)
       vkBindImageMemory2 = vkBindImageMemory2KHR;
     vkBuildAccelerationStructuresKHR = PFN_vkBuildAccelerationStructuresKHR(
@@ -121250,10 +124059,10 @@
         vkGetInstanceProcAddr(instance, "vkCmdBeginQueryIndexedEXT"));
     vkCmdBeginRenderPass = PFN_vkCmdBeginRenderPass(
         vkGetInstanceProcAddr(instance, "vkCmdBeginRenderPass"));
-    vkCmdBeginRenderPass2KHR = PFN_vkCmdBeginRenderPass2KHR(
-        vkGetInstanceProcAddr(instance, "vkCmdBeginRenderPass2KHR"));
     vkCmdBeginRenderPass2 = PFN_vkCmdBeginRenderPass2(
         vkGetInstanceProcAddr(instance, "vkCmdBeginRenderPass2"));
+    vkCmdBeginRenderPass2KHR = PFN_vkCmdBeginRenderPass2KHR(
+        vkGetInstanceProcAddr(instance, "vkCmdBeginRenderPass2KHR"));
     if (!vkCmdBeginRenderPass2)
       vkCmdBeginRenderPass2 = vkCmdBeginRenderPass2KHR;
     vkCmdBeginTransformFeedbackEXT = PFN_vkCmdBeginTransformFeedbackEXT(
@@ -121329,10 +124138,10 @@
         vkGetInstanceProcAddr(instance, "vkCmdDebugMarkerInsertEXT"));
     vkCmdDispatch =
         PFN_vkCmdDispatch(vkGetInstanceProcAddr(instance, "vkCmdDispatch"));
-    vkCmdDispatchBaseKHR = PFN_vkCmdDispatchBaseKHR(
-        vkGetInstanceProcAddr(instance, "vkCmdDispatchBaseKHR"));
     vkCmdDispatchBase = PFN_vkCmdDispatchBase(
         vkGetInstanceProcAddr(instance, "vkCmdDispatchBase"));
+    vkCmdDispatchBaseKHR = PFN_vkCmdDispatchBaseKHR(
+        vkGetInstanceProcAddr(instance, "vkCmdDispatchBaseKHR"));
     if (!vkCmdDispatchBase)
       vkCmdDispatchBase = vkCmdDispatchBaseKHR;
     vkCmdDispatchIndirect = PFN_vkCmdDispatchIndirect(
@@ -121342,30 +124151,30 @@
         vkGetInstanceProcAddr(instance, "vkCmdDrawIndexed"));
     vkCmdDrawIndexedIndirect = PFN_vkCmdDrawIndexedIndirect(
         vkGetInstanceProcAddr(instance, "vkCmdDrawIndexedIndirect"));
-    vkCmdDrawIndexedIndirectCountAMD = PFN_vkCmdDrawIndexedIndirectCountAMD(
-        vkGetInstanceProcAddr(instance, "vkCmdDrawIndexedIndirectCountAMD"));
-    vkCmdDrawIndexedIndirectCountKHR = PFN_vkCmdDrawIndexedIndirectCountKHR(
-        vkGetInstanceProcAddr(instance, "vkCmdDrawIndexedIndirectCountKHR"));
     vkCmdDrawIndexedIndirectCount = PFN_vkCmdDrawIndexedIndirectCount(
         vkGetInstanceProcAddr(instance, "vkCmdDrawIndexedIndirectCount"));
-    if (!vkCmdDrawIndexedIndirectCount)
-      vkCmdDrawIndexedIndirectCount = vkCmdDrawIndexedIndirectCountKHR;
+    vkCmdDrawIndexedIndirectCountAMD = PFN_vkCmdDrawIndexedIndirectCountAMD(
+        vkGetInstanceProcAddr(instance, "vkCmdDrawIndexedIndirectCountAMD"));
     if (!vkCmdDrawIndexedIndirectCount)
       vkCmdDrawIndexedIndirectCount = vkCmdDrawIndexedIndirectCountAMD;
+    vkCmdDrawIndexedIndirectCountKHR = PFN_vkCmdDrawIndexedIndirectCountKHR(
+        vkGetInstanceProcAddr(instance, "vkCmdDrawIndexedIndirectCountKHR"));
+    if (!vkCmdDrawIndexedIndirectCount)
+      vkCmdDrawIndexedIndirectCount = vkCmdDrawIndexedIndirectCountKHR;
     vkCmdDrawIndirect = PFN_vkCmdDrawIndirect(
         vkGetInstanceProcAddr(instance, "vkCmdDrawIndirect"));
     vkCmdDrawIndirectByteCountEXT = PFN_vkCmdDrawIndirectByteCountEXT(
         vkGetInstanceProcAddr(instance, "vkCmdDrawIndirectByteCountEXT"));
-    vkCmdDrawIndirectCountAMD = PFN_vkCmdDrawIndirectCountAMD(
-        vkGetInstanceProcAddr(instance, "vkCmdDrawIndirectCountAMD"));
-    vkCmdDrawIndirectCountKHR = PFN_vkCmdDrawIndirectCountKHR(
-        vkGetInstanceProcAddr(instance, "vkCmdDrawIndirectCountKHR"));
     vkCmdDrawIndirectCount = PFN_vkCmdDrawIndirectCount(
         vkGetInstanceProcAddr(instance, "vkCmdDrawIndirectCount"));
-    if (!vkCmdDrawIndirectCount)
-      vkCmdDrawIndirectCount = vkCmdDrawIndirectCountKHR;
+    vkCmdDrawIndirectCountAMD = PFN_vkCmdDrawIndirectCountAMD(
+        vkGetInstanceProcAddr(instance, "vkCmdDrawIndirectCountAMD"));
     if (!vkCmdDrawIndirectCount)
       vkCmdDrawIndirectCount = vkCmdDrawIndirectCountAMD;
+    vkCmdDrawIndirectCountKHR = PFN_vkCmdDrawIndirectCountKHR(
+        vkGetInstanceProcAddr(instance, "vkCmdDrawIndirectCountKHR"));
+    if (!vkCmdDrawIndirectCount)
+      vkCmdDrawIndirectCount = vkCmdDrawIndirectCountKHR;
     vkCmdDrawMeshTasksIndirectCountNV = PFN_vkCmdDrawMeshTasksIndirectCountNV(
         vkGetInstanceProcAddr(instance, "vkCmdDrawMeshTasksIndirectCountNV"));
     vkCmdDrawMeshTasksIndirectNV = PFN_vkCmdDrawMeshTasksIndirectNV(
@@ -121382,10 +124191,10 @@
         vkGetInstanceProcAddr(instance, "vkCmdEndQueryIndexedEXT"));
     vkCmdEndRenderPass = PFN_vkCmdEndRenderPass(
         vkGetInstanceProcAddr(instance, "vkCmdEndRenderPass"));
-    vkCmdEndRenderPass2KHR = PFN_vkCmdEndRenderPass2KHR(
-        vkGetInstanceProcAddr(instance, "vkCmdEndRenderPass2KHR"));
     vkCmdEndRenderPass2 = PFN_vkCmdEndRenderPass2(
         vkGetInstanceProcAddr(instance, "vkCmdEndRenderPass2"));
+    vkCmdEndRenderPass2KHR = PFN_vkCmdEndRenderPass2KHR(
+        vkGetInstanceProcAddr(instance, "vkCmdEndRenderPass2KHR"));
     if (!vkCmdEndRenderPass2)
       vkCmdEndRenderPass2 = vkCmdEndRenderPass2KHR;
     vkCmdEndTransformFeedbackEXT = PFN_vkCmdEndTransformFeedbackEXT(
@@ -121400,10 +124209,10 @@
         vkGetInstanceProcAddr(instance, "vkCmdInsertDebugUtilsLabelEXT"));
     vkCmdNextSubpass = PFN_vkCmdNextSubpass(
         vkGetInstanceProcAddr(instance, "vkCmdNextSubpass"));
-    vkCmdNextSubpass2KHR = PFN_vkCmdNextSubpass2KHR(
-        vkGetInstanceProcAddr(instance, "vkCmdNextSubpass2KHR"));
     vkCmdNextSubpass2 = PFN_vkCmdNextSubpass2(
         vkGetInstanceProcAddr(instance, "vkCmdNextSubpass2"));
+    vkCmdNextSubpass2KHR = PFN_vkCmdNextSubpass2KHR(
+        vkGetInstanceProcAddr(instance, "vkCmdNextSubpass2KHR"));
     if (!vkCmdNextSubpass2)
       vkCmdNextSubpass2 = vkCmdNextSubpass2KHR;
     vkCmdPipelineBarrier = PFN_vkCmdPipelineBarrier(
@@ -121449,10 +124258,10 @@
         vkGetInstanceProcAddr(instance, "vkCmdSetDepthTestEnableEXT"));
     vkCmdSetDepthWriteEnableEXT = PFN_vkCmdSetDepthWriteEnableEXT(
         vkGetInstanceProcAddr(instance, "vkCmdSetDepthWriteEnableEXT"));
-    vkCmdSetDeviceMaskKHR = PFN_vkCmdSetDeviceMaskKHR(
-        vkGetInstanceProcAddr(instance, "vkCmdSetDeviceMaskKHR"));
     vkCmdSetDeviceMask = PFN_vkCmdSetDeviceMask(
         vkGetInstanceProcAddr(instance, "vkCmdSetDeviceMask"));
+    vkCmdSetDeviceMaskKHR = PFN_vkCmdSetDeviceMaskKHR(
+        vkGetInstanceProcAddr(instance, "vkCmdSetDeviceMaskKHR"));
     if (!vkCmdSetDeviceMask)
       vkCmdSetDeviceMask = vkCmdSetDeviceMaskKHR;
     vkCmdSetDiscardRectangleEXT = PFN_vkCmdSetDiscardRectangleEXT(
@@ -121556,6 +124365,10 @@
     vkCreateBufferCollectionFUCHSIA = PFN_vkCreateBufferCollectionFUCHSIA(
         vkGetInstanceProcAddr(instance, "vkCreateBufferCollectionFUCHSIA"));
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+    vkCreateBufferCollectionFUCHSIAX = PFN_vkCreateBufferCollectionFUCHSIAX(
+        vkGetInstanceProcAddr(instance, "vkCreateBufferCollectionFUCHSIAX"));
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
     vkCreateBufferView = PFN_vkCreateBufferView(
         vkGetInstanceProcAddr(instance, "vkCreateBufferView"));
     vkCreateCommandPool = PFN_vkCreateCommandPool(
@@ -121568,11 +124381,11 @@
         vkGetInstanceProcAddr(instance, "vkCreateDescriptorPool"));
     vkCreateDescriptorSetLayout = PFN_vkCreateDescriptorSetLayout(
         vkGetInstanceProcAddr(instance, "vkCreateDescriptorSetLayout"));
+    vkCreateDescriptorUpdateTemplate = PFN_vkCreateDescriptorUpdateTemplate(
+        vkGetInstanceProcAddr(instance, "vkCreateDescriptorUpdateTemplate"));
     vkCreateDescriptorUpdateTemplateKHR =
         PFN_vkCreateDescriptorUpdateTemplateKHR(vkGetInstanceProcAddr(
             instance, "vkCreateDescriptorUpdateTemplateKHR"));
-    vkCreateDescriptorUpdateTemplate = PFN_vkCreateDescriptorUpdateTemplate(
-        vkGetInstanceProcAddr(instance, "vkCreateDescriptorUpdateTemplate"));
     if (!vkCreateDescriptorUpdateTemplate)
       vkCreateDescriptorUpdateTemplate = vkCreateDescriptorUpdateTemplateKHR;
     vkCreateEvent =
@@ -121603,18 +124416,18 @@
         vkGetInstanceProcAddr(instance, "vkCreateRayTracingPipelinesNV"));
     vkCreateRenderPass = PFN_vkCreateRenderPass(
         vkGetInstanceProcAddr(instance, "vkCreateRenderPass"));
-    vkCreateRenderPass2KHR = PFN_vkCreateRenderPass2KHR(
-        vkGetInstanceProcAddr(instance, "vkCreateRenderPass2KHR"));
     vkCreateRenderPass2 = PFN_vkCreateRenderPass2(
         vkGetInstanceProcAddr(instance, "vkCreateRenderPass2"));
+    vkCreateRenderPass2KHR = PFN_vkCreateRenderPass2KHR(
+        vkGetInstanceProcAddr(instance, "vkCreateRenderPass2KHR"));
     if (!vkCreateRenderPass2)
       vkCreateRenderPass2 = vkCreateRenderPass2KHR;
     vkCreateSampler =
         PFN_vkCreateSampler(vkGetInstanceProcAddr(instance, "vkCreateSampler"));
-    vkCreateSamplerYcbcrConversionKHR = PFN_vkCreateSamplerYcbcrConversionKHR(
-        vkGetInstanceProcAddr(instance, "vkCreateSamplerYcbcrConversionKHR"));
     vkCreateSamplerYcbcrConversion = PFN_vkCreateSamplerYcbcrConversion(
         vkGetInstanceProcAddr(instance, "vkCreateSamplerYcbcrConversion"));
+    vkCreateSamplerYcbcrConversionKHR = PFN_vkCreateSamplerYcbcrConversionKHR(
+        vkGetInstanceProcAddr(instance, "vkCreateSamplerYcbcrConversionKHR"));
     if (!vkCreateSamplerYcbcrConversion)
       vkCreateSamplerYcbcrConversion = vkCreateSamplerYcbcrConversionKHR;
     vkCreateSemaphore = PFN_vkCreateSemaphore(
@@ -121643,6 +124456,10 @@
     vkDestroyBufferCollectionFUCHSIA = PFN_vkDestroyBufferCollectionFUCHSIA(
         vkGetInstanceProcAddr(instance, "vkDestroyBufferCollectionFUCHSIA"));
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+    vkDestroyBufferCollectionFUCHSIAX = PFN_vkDestroyBufferCollectionFUCHSIAX(
+        vkGetInstanceProcAddr(instance, "vkDestroyBufferCollectionFUCHSIAX"));
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
     vkDestroyBufferView = PFN_vkDestroyBufferView(
         vkGetInstanceProcAddr(instance, "vkDestroyBufferView"));
     vkDestroyCommandPool = PFN_vkDestroyCommandPool(
@@ -121653,11 +124470,11 @@
         vkGetInstanceProcAddr(instance, "vkDestroyDescriptorPool"));
     vkDestroyDescriptorSetLayout = PFN_vkDestroyDescriptorSetLayout(
         vkGetInstanceProcAddr(instance, "vkDestroyDescriptorSetLayout"));
+    vkDestroyDescriptorUpdateTemplate = PFN_vkDestroyDescriptorUpdateTemplate(
+        vkGetInstanceProcAddr(instance, "vkDestroyDescriptorUpdateTemplate"));
     vkDestroyDescriptorUpdateTemplateKHR =
         PFN_vkDestroyDescriptorUpdateTemplateKHR(vkGetInstanceProcAddr(
             instance, "vkDestroyDescriptorUpdateTemplateKHR"));
-    vkDestroyDescriptorUpdateTemplate = PFN_vkDestroyDescriptorUpdateTemplate(
-        vkGetInstanceProcAddr(instance, "vkDestroyDescriptorUpdateTemplate"));
     if (!vkDestroyDescriptorUpdateTemplate)
       vkDestroyDescriptorUpdateTemplate = vkDestroyDescriptorUpdateTemplateKHR;
     vkDestroyDevice =
@@ -121688,10 +124505,10 @@
         vkGetInstanceProcAddr(instance, "vkDestroyRenderPass"));
     vkDestroySampler = PFN_vkDestroySampler(
         vkGetInstanceProcAddr(instance, "vkDestroySampler"));
-    vkDestroySamplerYcbcrConversionKHR = PFN_vkDestroySamplerYcbcrConversionKHR(
-        vkGetInstanceProcAddr(instance, "vkDestroySamplerYcbcrConversionKHR"));
     vkDestroySamplerYcbcrConversion = PFN_vkDestroySamplerYcbcrConversion(
         vkGetInstanceProcAddr(instance, "vkDestroySamplerYcbcrConversion"));
+    vkDestroySamplerYcbcrConversionKHR = PFN_vkDestroySamplerYcbcrConversionKHR(
+        vkGetInstanceProcAddr(instance, "vkDestroySamplerYcbcrConversionKHR"));
     if (!vkDestroySamplerYcbcrConversion)
       vkDestroySamplerYcbcrConversion = vkDestroySamplerYcbcrConversionKHR;
     vkDestroySemaphore = PFN_vkDestroySemaphore(
@@ -121739,32 +124556,42 @@
             instance, "vkGetBufferCollectionProperties2FUCHSIA"));
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 #if defined(VK_USE_PLATFORM_FUCHSIA)
+    vkGetBufferCollectionProperties2FUCHSIAX =
+        PFN_vkGetBufferCollectionProperties2FUCHSIAX(vkGetInstanceProcAddr(
+            instance, "vkGetBufferCollectionProperties2FUCHSIAX"));
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+#if defined(VK_USE_PLATFORM_FUCHSIA)
     vkGetBufferCollectionPropertiesFUCHSIA =
         PFN_vkGetBufferCollectionPropertiesFUCHSIA(vkGetInstanceProcAddr(
             instance, "vkGetBufferCollectionPropertiesFUCHSIA"));
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
-    vkGetBufferDeviceAddressEXT = PFN_vkGetBufferDeviceAddressEXT(
-        vkGetInstanceProcAddr(instance, "vkGetBufferDeviceAddressEXT"));
-    vkGetBufferDeviceAddressKHR = PFN_vkGetBufferDeviceAddressKHR(
-        vkGetInstanceProcAddr(instance, "vkGetBufferDeviceAddressKHR"));
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+    vkGetBufferCollectionPropertiesFUCHSIAX =
+        PFN_vkGetBufferCollectionPropertiesFUCHSIAX(vkGetInstanceProcAddr(
+            instance, "vkGetBufferCollectionPropertiesFUCHSIAX"));
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
     vkGetBufferDeviceAddress = PFN_vkGetBufferDeviceAddress(
         vkGetInstanceProcAddr(instance, "vkGetBufferDeviceAddress"));
-    if (!vkGetBufferDeviceAddress)
-      vkGetBufferDeviceAddress = vkGetBufferDeviceAddressKHR;
+    vkGetBufferDeviceAddressEXT = PFN_vkGetBufferDeviceAddressEXT(
+        vkGetInstanceProcAddr(instance, "vkGetBufferDeviceAddressEXT"));
     if (!vkGetBufferDeviceAddress)
       vkGetBufferDeviceAddress = vkGetBufferDeviceAddressEXT;
+    vkGetBufferDeviceAddressKHR = PFN_vkGetBufferDeviceAddressKHR(
+        vkGetInstanceProcAddr(instance, "vkGetBufferDeviceAddressKHR"));
+    if (!vkGetBufferDeviceAddress)
+      vkGetBufferDeviceAddress = vkGetBufferDeviceAddressKHR;
     vkGetBufferMemoryRequirements = PFN_vkGetBufferMemoryRequirements(
         vkGetInstanceProcAddr(instance, "vkGetBufferMemoryRequirements"));
-    vkGetBufferMemoryRequirements2KHR = PFN_vkGetBufferMemoryRequirements2KHR(
-        vkGetInstanceProcAddr(instance, "vkGetBufferMemoryRequirements2KHR"));
     vkGetBufferMemoryRequirements2 = PFN_vkGetBufferMemoryRequirements2(
         vkGetInstanceProcAddr(instance, "vkGetBufferMemoryRequirements2"));
+    vkGetBufferMemoryRequirements2KHR = PFN_vkGetBufferMemoryRequirements2KHR(
+        vkGetInstanceProcAddr(instance, "vkGetBufferMemoryRequirements2KHR"));
     if (!vkGetBufferMemoryRequirements2)
       vkGetBufferMemoryRequirements2 = vkGetBufferMemoryRequirements2KHR;
-    vkGetBufferOpaqueCaptureAddressKHR = PFN_vkGetBufferOpaqueCaptureAddressKHR(
-        vkGetInstanceProcAddr(instance, "vkGetBufferOpaqueCaptureAddressKHR"));
     vkGetBufferOpaqueCaptureAddress = PFN_vkGetBufferOpaqueCaptureAddress(
         vkGetInstanceProcAddr(instance, "vkGetBufferOpaqueCaptureAddress"));
+    vkGetBufferOpaqueCaptureAddressKHR = PFN_vkGetBufferOpaqueCaptureAddressKHR(
+        vkGetInstanceProcAddr(instance, "vkGetBufferOpaqueCaptureAddressKHR"));
     if (!vkGetBufferOpaqueCaptureAddress)
       vkGetBufferOpaqueCaptureAddress = vkGetBufferOpaqueCaptureAddressKHR;
     vkGetCalibratedTimestampsEXT = PFN_vkGetCalibratedTimestampsEXT(
@@ -121774,21 +124601,21 @@
             instance, "vkGetDeferredOperationMaxConcurrencyKHR"));
     vkGetDeferredOperationResultKHR = PFN_vkGetDeferredOperationResultKHR(
         vkGetInstanceProcAddr(instance, "vkGetDeferredOperationResultKHR"));
-    vkGetDescriptorSetLayoutSupportKHR = PFN_vkGetDescriptorSetLayoutSupportKHR(
-        vkGetInstanceProcAddr(instance, "vkGetDescriptorSetLayoutSupportKHR"));
     vkGetDescriptorSetLayoutSupport = PFN_vkGetDescriptorSetLayoutSupport(
         vkGetInstanceProcAddr(instance, "vkGetDescriptorSetLayoutSupport"));
+    vkGetDescriptorSetLayoutSupportKHR = PFN_vkGetDescriptorSetLayoutSupportKHR(
+        vkGetInstanceProcAddr(instance, "vkGetDescriptorSetLayoutSupportKHR"));
     if (!vkGetDescriptorSetLayoutSupport)
       vkGetDescriptorSetLayoutSupport = vkGetDescriptorSetLayoutSupportKHR;
     vkGetDeviceAccelerationStructureCompatibilityKHR =
         PFN_vkGetDeviceAccelerationStructureCompatibilityKHR(
             vkGetInstanceProcAddr(
                 instance, "vkGetDeviceAccelerationStructureCompatibilityKHR"));
+    vkGetDeviceGroupPeerMemoryFeatures = PFN_vkGetDeviceGroupPeerMemoryFeatures(
+        vkGetInstanceProcAddr(instance, "vkGetDeviceGroupPeerMemoryFeatures"));
     vkGetDeviceGroupPeerMemoryFeaturesKHR =
         PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR(vkGetInstanceProcAddr(
             instance, "vkGetDeviceGroupPeerMemoryFeaturesKHR"));
-    vkGetDeviceGroupPeerMemoryFeatures = PFN_vkGetDeviceGroupPeerMemoryFeatures(
-        vkGetInstanceProcAddr(instance, "vkGetDeviceGroupPeerMemoryFeatures"));
     if (!vkGetDeviceGroupPeerMemoryFeatures)
       vkGetDeviceGroupPeerMemoryFeatures =
           vkGetDeviceGroupPeerMemoryFeaturesKHR;
@@ -121805,12 +124632,12 @@
             instance, "vkGetDeviceGroupSurfacePresentModesKHR"));
     vkGetDeviceMemoryCommitment = PFN_vkGetDeviceMemoryCommitment(
         vkGetInstanceProcAddr(instance, "vkGetDeviceMemoryCommitment"));
-    vkGetDeviceMemoryOpaqueCaptureAddressKHR =
-        PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR(vkGetInstanceProcAddr(
-            instance, "vkGetDeviceMemoryOpaqueCaptureAddressKHR"));
     vkGetDeviceMemoryOpaqueCaptureAddress =
         PFN_vkGetDeviceMemoryOpaqueCaptureAddress(vkGetInstanceProcAddr(
             instance, "vkGetDeviceMemoryOpaqueCaptureAddress"));
+    vkGetDeviceMemoryOpaqueCaptureAddressKHR =
+        PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR(vkGetInstanceProcAddr(
+            instance, "vkGetDeviceMemoryOpaqueCaptureAddressKHR"));
     if (!vkGetDeviceMemoryOpaqueCaptureAddress)
       vkGetDeviceMemoryOpaqueCaptureAddress =
           vkGetDeviceMemoryOpaqueCaptureAddressKHR;
@@ -121838,20 +124665,20 @@
             instance, "vkGetImageDrmFormatModifierPropertiesEXT"));
     vkGetImageMemoryRequirements = PFN_vkGetImageMemoryRequirements(
         vkGetInstanceProcAddr(instance, "vkGetImageMemoryRequirements"));
-    vkGetImageMemoryRequirements2KHR = PFN_vkGetImageMemoryRequirements2KHR(
-        vkGetInstanceProcAddr(instance, "vkGetImageMemoryRequirements2KHR"));
     vkGetImageMemoryRequirements2 = PFN_vkGetImageMemoryRequirements2(
         vkGetInstanceProcAddr(instance, "vkGetImageMemoryRequirements2"));
+    vkGetImageMemoryRequirements2KHR = PFN_vkGetImageMemoryRequirements2KHR(
+        vkGetInstanceProcAddr(instance, "vkGetImageMemoryRequirements2KHR"));
     if (!vkGetImageMemoryRequirements2)
       vkGetImageMemoryRequirements2 = vkGetImageMemoryRequirements2KHR;
     vkGetImageSparseMemoryRequirements = PFN_vkGetImageSparseMemoryRequirements(
         vkGetInstanceProcAddr(instance, "vkGetImageSparseMemoryRequirements"));
-    vkGetImageSparseMemoryRequirements2KHR =
-        PFN_vkGetImageSparseMemoryRequirements2KHR(vkGetInstanceProcAddr(
-            instance, "vkGetImageSparseMemoryRequirements2KHR"));
     vkGetImageSparseMemoryRequirements2 =
         PFN_vkGetImageSparseMemoryRequirements2(vkGetInstanceProcAddr(
             instance, "vkGetImageSparseMemoryRequirements2"));
+    vkGetImageSparseMemoryRequirements2KHR =
+        PFN_vkGetImageSparseMemoryRequirements2KHR(vkGetInstanceProcAddr(
+            instance, "vkGetImageSparseMemoryRequirements2KHR"));
     if (!vkGetImageSparseMemoryRequirements2)
       vkGetImageSparseMemoryRequirements2 =
           vkGetImageSparseMemoryRequirements2KHR;
@@ -121923,12 +124750,12 @@
         PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(
             vkGetInstanceProcAddr(
                 instance, "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR"));
-    vkGetRayTracingShaderGroupHandlesNV =
-        PFN_vkGetRayTracingShaderGroupHandlesNV(vkGetInstanceProcAddr(
-            instance, "vkGetRayTracingShaderGroupHandlesNV"));
     vkGetRayTracingShaderGroupHandlesKHR =
         PFN_vkGetRayTracingShaderGroupHandlesKHR(vkGetInstanceProcAddr(
             instance, "vkGetRayTracingShaderGroupHandlesKHR"));
+    vkGetRayTracingShaderGroupHandlesNV =
+        PFN_vkGetRayTracingShaderGroupHandlesNV(vkGetInstanceProcAddr(
+            instance, "vkGetRayTracingShaderGroupHandlesNV"));
     if (!vkGetRayTracingShaderGroupHandlesKHR)
       vkGetRayTracingShaderGroupHandlesKHR =
           vkGetRayTracingShaderGroupHandlesNV;
@@ -121939,10 +124766,10 @@
         vkGetInstanceProcAddr(instance, "vkGetRefreshCycleDurationGOOGLE"));
     vkGetRenderAreaGranularity = PFN_vkGetRenderAreaGranularity(
         vkGetInstanceProcAddr(instance, "vkGetRenderAreaGranularity"));
-    vkGetSemaphoreCounterValueKHR = PFN_vkGetSemaphoreCounterValueKHR(
-        vkGetInstanceProcAddr(instance, "vkGetSemaphoreCounterValueKHR"));
     vkGetSemaphoreCounterValue = PFN_vkGetSemaphoreCounterValue(
         vkGetInstanceProcAddr(instance, "vkGetSemaphoreCounterValue"));
+    vkGetSemaphoreCounterValueKHR = PFN_vkGetSemaphoreCounterValueKHR(
+        vkGetInstanceProcAddr(instance, "vkGetSemaphoreCounterValueKHR"));
     if (!vkGetSemaphoreCounterValue)
       vkGetSemaphoreCounterValue = vkGetSemaphoreCounterValueKHR;
     vkGetSemaphoreFdKHR = PFN_vkGetSemaphoreFdKHR(
@@ -122039,10 +124866,10 @@
         PFN_vkResetEvent(vkGetInstanceProcAddr(instance, "vkResetEvent"));
     vkResetFences =
         PFN_vkResetFences(vkGetInstanceProcAddr(instance, "vkResetFences"));
-    vkResetQueryPoolEXT = PFN_vkResetQueryPoolEXT(
-        vkGetInstanceProcAddr(instance, "vkResetQueryPoolEXT"));
     vkResetQueryPool = PFN_vkResetQueryPool(
         vkGetInstanceProcAddr(instance, "vkResetQueryPool"));
+    vkResetQueryPoolEXT = PFN_vkResetQueryPoolEXT(
+        vkGetInstanceProcAddr(instance, "vkResetQueryPoolEXT"));
     if (!vkResetQueryPool)
       vkResetQueryPool = vkResetQueryPoolEXT;
 #if defined(VK_USE_PLATFORM_FUCHSIA)
@@ -122051,15 +124878,31 @@
             instance, "vkSetBufferCollectionBufferConstraintsFUCHSIA"));
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 #if defined(VK_USE_PLATFORM_FUCHSIA)
+    vkSetBufferCollectionBufferConstraintsFUCHSIAX =
+        PFN_vkSetBufferCollectionBufferConstraintsFUCHSIAX(
+            vkGetInstanceProcAddr(
+                instance, "vkSetBufferCollectionBufferConstraintsFUCHSIAX"));
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+#if defined(VK_USE_PLATFORM_FUCHSIA)
     vkSetBufferCollectionConstraintsFUCHSIA =
         PFN_vkSetBufferCollectionConstraintsFUCHSIA(vkGetInstanceProcAddr(
             instance, "vkSetBufferCollectionConstraintsFUCHSIA"));
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 #if defined(VK_USE_PLATFORM_FUCHSIA)
+    vkSetBufferCollectionConstraintsFUCHSIAX =
+        PFN_vkSetBufferCollectionConstraintsFUCHSIAX(vkGetInstanceProcAddr(
+            instance, "vkSetBufferCollectionConstraintsFUCHSIAX"));
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+#if defined(VK_USE_PLATFORM_FUCHSIA)
     vkSetBufferCollectionImageConstraintsFUCHSIA =
         PFN_vkSetBufferCollectionImageConstraintsFUCHSIA(vkGetInstanceProcAddr(
             instance, "vkSetBufferCollectionImageConstraintsFUCHSIA"));
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+    vkSetBufferCollectionImageConstraintsFUCHSIAX =
+        PFN_vkSetBufferCollectionImageConstraintsFUCHSIAX(vkGetInstanceProcAddr(
+            instance, "vkSetBufferCollectionImageConstraintsFUCHSIAX"));
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
     vkSetDebugUtilsObjectNameEXT = PFN_vkSetDebugUtilsObjectNameEXT(
         vkGetInstanceProcAddr(instance, "vkSetDebugUtilsObjectNameEXT"));
     vkSetDebugUtilsObjectTagEXT = PFN_vkSetDebugUtilsObjectTagEXT(
@@ -122071,16 +124914,16 @@
         vkGetInstanceProcAddr(instance, "vkSetLocalDimmingAMD"));
     vkSetPrivateDataEXT = PFN_vkSetPrivateDataEXT(
         vkGetInstanceProcAddr(instance, "vkSetPrivateDataEXT"));
-    vkSignalSemaphoreKHR = PFN_vkSignalSemaphoreKHR(
-        vkGetInstanceProcAddr(instance, "vkSignalSemaphoreKHR"));
     vkSignalSemaphore = PFN_vkSignalSemaphore(
         vkGetInstanceProcAddr(instance, "vkSignalSemaphore"));
+    vkSignalSemaphoreKHR = PFN_vkSignalSemaphoreKHR(
+        vkGetInstanceProcAddr(instance, "vkSignalSemaphoreKHR"));
     if (!vkSignalSemaphore)
       vkSignalSemaphore = vkSignalSemaphoreKHR;
-    vkTrimCommandPoolKHR = PFN_vkTrimCommandPoolKHR(
-        vkGetInstanceProcAddr(instance, "vkTrimCommandPoolKHR"));
     vkTrimCommandPool = PFN_vkTrimCommandPool(
         vkGetInstanceProcAddr(instance, "vkTrimCommandPool"));
+    vkTrimCommandPoolKHR = PFN_vkTrimCommandPoolKHR(
+        vkGetInstanceProcAddr(instance, "vkTrimCommandPoolKHR"));
     if (!vkTrimCommandPool)
       vkTrimCommandPool = vkTrimCommandPoolKHR;
 #if defined(VK_USE_PLATFORM_FUCHSIA)
@@ -122092,21 +124935,21 @@
         vkGetInstanceProcAddr(instance, "vkUninitializePerformanceApiINTEL"));
     vkUnmapMemory =
         PFN_vkUnmapMemory(vkGetInstanceProcAddr(instance, "vkUnmapMemory"));
+    vkUpdateDescriptorSetWithTemplate = PFN_vkUpdateDescriptorSetWithTemplate(
+        vkGetInstanceProcAddr(instance, "vkUpdateDescriptorSetWithTemplate"));
     vkUpdateDescriptorSetWithTemplateKHR =
         PFN_vkUpdateDescriptorSetWithTemplateKHR(vkGetInstanceProcAddr(
             instance, "vkUpdateDescriptorSetWithTemplateKHR"));
-    vkUpdateDescriptorSetWithTemplate = PFN_vkUpdateDescriptorSetWithTemplate(
-        vkGetInstanceProcAddr(instance, "vkUpdateDescriptorSetWithTemplate"));
     if (!vkUpdateDescriptorSetWithTemplate)
       vkUpdateDescriptorSetWithTemplate = vkUpdateDescriptorSetWithTemplateKHR;
     vkUpdateDescriptorSets = PFN_vkUpdateDescriptorSets(
         vkGetInstanceProcAddr(instance, "vkUpdateDescriptorSets"));
     vkWaitForFences =
         PFN_vkWaitForFences(vkGetInstanceProcAddr(instance, "vkWaitForFences"));
-    vkWaitSemaphoresKHR = PFN_vkWaitSemaphoresKHR(
-        vkGetInstanceProcAddr(instance, "vkWaitSemaphoresKHR"));
     vkWaitSemaphores = PFN_vkWaitSemaphores(
         vkGetInstanceProcAddr(instance, "vkWaitSemaphores"));
+    vkWaitSemaphoresKHR = PFN_vkWaitSemaphoresKHR(
+        vkGetInstanceProcAddr(instance, "vkWaitSemaphoresKHR"));
     if (!vkWaitSemaphores)
       vkWaitSemaphores = vkWaitSemaphoresKHR;
     vkWriteAccelerationStructuresPropertiesKHR =
@@ -122143,18 +124986,18 @@
             vkGetDeviceProcAddr(device, "vkBindAccelerationStructureMemoryNV"));
     vkBindBufferMemory = PFN_vkBindBufferMemory(
         vkGetDeviceProcAddr(device, "vkBindBufferMemory"));
-    vkBindBufferMemory2KHR = PFN_vkBindBufferMemory2KHR(
-        vkGetDeviceProcAddr(device, "vkBindBufferMemory2KHR"));
     vkBindBufferMemory2 = PFN_vkBindBufferMemory2(
         vkGetDeviceProcAddr(device, "vkBindBufferMemory2"));
+    vkBindBufferMemory2KHR = PFN_vkBindBufferMemory2KHR(
+        vkGetDeviceProcAddr(device, "vkBindBufferMemory2KHR"));
     if (!vkBindBufferMemory2)
       vkBindBufferMemory2 = vkBindBufferMemory2KHR;
     vkBindImageMemory =
         PFN_vkBindImageMemory(vkGetDeviceProcAddr(device, "vkBindImageMemory"));
-    vkBindImageMemory2KHR = PFN_vkBindImageMemory2KHR(
-        vkGetDeviceProcAddr(device, "vkBindImageMemory2KHR"));
     vkBindImageMemory2 = PFN_vkBindImageMemory2(
         vkGetDeviceProcAddr(device, "vkBindImageMemory2"));
+    vkBindImageMemory2KHR = PFN_vkBindImageMemory2KHR(
+        vkGetDeviceProcAddr(device, "vkBindImageMemory2KHR"));
     if (!vkBindImageMemory2)
       vkBindImageMemory2 = vkBindImageMemory2KHR;
     vkBuildAccelerationStructuresKHR = PFN_vkBuildAccelerationStructuresKHR(
@@ -122169,10 +125012,10 @@
         vkGetDeviceProcAddr(device, "vkCmdBeginQueryIndexedEXT"));
     vkCmdBeginRenderPass = PFN_vkCmdBeginRenderPass(
         vkGetDeviceProcAddr(device, "vkCmdBeginRenderPass"));
-    vkCmdBeginRenderPass2KHR = PFN_vkCmdBeginRenderPass2KHR(
-        vkGetDeviceProcAddr(device, "vkCmdBeginRenderPass2KHR"));
     vkCmdBeginRenderPass2 = PFN_vkCmdBeginRenderPass2(
         vkGetDeviceProcAddr(device, "vkCmdBeginRenderPass2"));
+    vkCmdBeginRenderPass2KHR = PFN_vkCmdBeginRenderPass2KHR(
+        vkGetDeviceProcAddr(device, "vkCmdBeginRenderPass2KHR"));
     if (!vkCmdBeginRenderPass2)
       vkCmdBeginRenderPass2 = vkCmdBeginRenderPass2KHR;
     vkCmdBeginTransformFeedbackEXT = PFN_vkCmdBeginTransformFeedbackEXT(
@@ -122248,10 +125091,10 @@
         vkGetDeviceProcAddr(device, "vkCmdDebugMarkerInsertEXT"));
     vkCmdDispatch =
         PFN_vkCmdDispatch(vkGetDeviceProcAddr(device, "vkCmdDispatch"));
-    vkCmdDispatchBaseKHR = PFN_vkCmdDispatchBaseKHR(
-        vkGetDeviceProcAddr(device, "vkCmdDispatchBaseKHR"));
     vkCmdDispatchBase =
         PFN_vkCmdDispatchBase(vkGetDeviceProcAddr(device, "vkCmdDispatchBase"));
+    vkCmdDispatchBaseKHR = PFN_vkCmdDispatchBaseKHR(
+        vkGetDeviceProcAddr(device, "vkCmdDispatchBaseKHR"));
     if (!vkCmdDispatchBase)
       vkCmdDispatchBase = vkCmdDispatchBaseKHR;
     vkCmdDispatchIndirect = PFN_vkCmdDispatchIndirect(
@@ -122261,30 +125104,30 @@
         PFN_vkCmdDrawIndexed(vkGetDeviceProcAddr(device, "vkCmdDrawIndexed"));
     vkCmdDrawIndexedIndirect = PFN_vkCmdDrawIndexedIndirect(
         vkGetDeviceProcAddr(device, "vkCmdDrawIndexedIndirect"));
-    vkCmdDrawIndexedIndirectCountAMD = PFN_vkCmdDrawIndexedIndirectCountAMD(
-        vkGetDeviceProcAddr(device, "vkCmdDrawIndexedIndirectCountAMD"));
-    vkCmdDrawIndexedIndirectCountKHR = PFN_vkCmdDrawIndexedIndirectCountKHR(
-        vkGetDeviceProcAddr(device, "vkCmdDrawIndexedIndirectCountKHR"));
     vkCmdDrawIndexedIndirectCount = PFN_vkCmdDrawIndexedIndirectCount(
         vkGetDeviceProcAddr(device, "vkCmdDrawIndexedIndirectCount"));
-    if (!vkCmdDrawIndexedIndirectCount)
-      vkCmdDrawIndexedIndirectCount = vkCmdDrawIndexedIndirectCountKHR;
+    vkCmdDrawIndexedIndirectCountAMD = PFN_vkCmdDrawIndexedIndirectCountAMD(
+        vkGetDeviceProcAddr(device, "vkCmdDrawIndexedIndirectCountAMD"));
     if (!vkCmdDrawIndexedIndirectCount)
       vkCmdDrawIndexedIndirectCount = vkCmdDrawIndexedIndirectCountAMD;
+    vkCmdDrawIndexedIndirectCountKHR = PFN_vkCmdDrawIndexedIndirectCountKHR(
+        vkGetDeviceProcAddr(device, "vkCmdDrawIndexedIndirectCountKHR"));
+    if (!vkCmdDrawIndexedIndirectCount)
+      vkCmdDrawIndexedIndirectCount = vkCmdDrawIndexedIndirectCountKHR;
     vkCmdDrawIndirect =
         PFN_vkCmdDrawIndirect(vkGetDeviceProcAddr(device, "vkCmdDrawIndirect"));
     vkCmdDrawIndirectByteCountEXT = PFN_vkCmdDrawIndirectByteCountEXT(
         vkGetDeviceProcAddr(device, "vkCmdDrawIndirectByteCountEXT"));
-    vkCmdDrawIndirectCountAMD = PFN_vkCmdDrawIndirectCountAMD(
-        vkGetDeviceProcAddr(device, "vkCmdDrawIndirectCountAMD"));
-    vkCmdDrawIndirectCountKHR = PFN_vkCmdDrawIndirectCountKHR(
-        vkGetDeviceProcAddr(device, "vkCmdDrawIndirectCountKHR"));
     vkCmdDrawIndirectCount = PFN_vkCmdDrawIndirectCount(
         vkGetDeviceProcAddr(device, "vkCmdDrawIndirectCount"));
-    if (!vkCmdDrawIndirectCount)
-      vkCmdDrawIndirectCount = vkCmdDrawIndirectCountKHR;
+    vkCmdDrawIndirectCountAMD = PFN_vkCmdDrawIndirectCountAMD(
+        vkGetDeviceProcAddr(device, "vkCmdDrawIndirectCountAMD"));
     if (!vkCmdDrawIndirectCount)
       vkCmdDrawIndirectCount = vkCmdDrawIndirectCountAMD;
+    vkCmdDrawIndirectCountKHR = PFN_vkCmdDrawIndirectCountKHR(
+        vkGetDeviceProcAddr(device, "vkCmdDrawIndirectCountKHR"));
+    if (!vkCmdDrawIndirectCount)
+      vkCmdDrawIndirectCount = vkCmdDrawIndirectCountKHR;
     vkCmdDrawMeshTasksIndirectCountNV = PFN_vkCmdDrawMeshTasksIndirectCountNV(
         vkGetDeviceProcAddr(device, "vkCmdDrawMeshTasksIndirectCountNV"));
     vkCmdDrawMeshTasksIndirectNV = PFN_vkCmdDrawMeshTasksIndirectNV(
@@ -122301,10 +125144,10 @@
         vkGetDeviceProcAddr(device, "vkCmdEndQueryIndexedEXT"));
     vkCmdEndRenderPass = PFN_vkCmdEndRenderPass(
         vkGetDeviceProcAddr(device, "vkCmdEndRenderPass"));
-    vkCmdEndRenderPass2KHR = PFN_vkCmdEndRenderPass2KHR(
-        vkGetDeviceProcAddr(device, "vkCmdEndRenderPass2KHR"));
     vkCmdEndRenderPass2 = PFN_vkCmdEndRenderPass2(
         vkGetDeviceProcAddr(device, "vkCmdEndRenderPass2"));
+    vkCmdEndRenderPass2KHR = PFN_vkCmdEndRenderPass2KHR(
+        vkGetDeviceProcAddr(device, "vkCmdEndRenderPass2KHR"));
     if (!vkCmdEndRenderPass2)
       vkCmdEndRenderPass2 = vkCmdEndRenderPass2KHR;
     vkCmdEndTransformFeedbackEXT = PFN_vkCmdEndTransformFeedbackEXT(
@@ -122319,10 +125162,10 @@
         vkGetDeviceProcAddr(device, "vkCmdInsertDebugUtilsLabelEXT"));
     vkCmdNextSubpass =
         PFN_vkCmdNextSubpass(vkGetDeviceProcAddr(device, "vkCmdNextSubpass"));
-    vkCmdNextSubpass2KHR = PFN_vkCmdNextSubpass2KHR(
-        vkGetDeviceProcAddr(device, "vkCmdNextSubpass2KHR"));
     vkCmdNextSubpass2 =
         PFN_vkCmdNextSubpass2(vkGetDeviceProcAddr(device, "vkCmdNextSubpass2"));
+    vkCmdNextSubpass2KHR = PFN_vkCmdNextSubpass2KHR(
+        vkGetDeviceProcAddr(device, "vkCmdNextSubpass2KHR"));
     if (!vkCmdNextSubpass2)
       vkCmdNextSubpass2 = vkCmdNextSubpass2KHR;
     vkCmdPipelineBarrier = PFN_vkCmdPipelineBarrier(
@@ -122368,10 +125211,10 @@
         vkGetDeviceProcAddr(device, "vkCmdSetDepthTestEnableEXT"));
     vkCmdSetDepthWriteEnableEXT = PFN_vkCmdSetDepthWriteEnableEXT(
         vkGetDeviceProcAddr(device, "vkCmdSetDepthWriteEnableEXT"));
-    vkCmdSetDeviceMaskKHR = PFN_vkCmdSetDeviceMaskKHR(
-        vkGetDeviceProcAddr(device, "vkCmdSetDeviceMaskKHR"));
     vkCmdSetDeviceMask = PFN_vkCmdSetDeviceMask(
         vkGetDeviceProcAddr(device, "vkCmdSetDeviceMask"));
+    vkCmdSetDeviceMaskKHR = PFN_vkCmdSetDeviceMaskKHR(
+        vkGetDeviceProcAddr(device, "vkCmdSetDeviceMaskKHR"));
     if (!vkCmdSetDeviceMask)
       vkCmdSetDeviceMask = vkCmdSetDeviceMaskKHR;
     vkCmdSetDiscardRectangleEXT = PFN_vkCmdSetDiscardRectangleEXT(
@@ -122475,6 +125318,10 @@
     vkCreateBufferCollectionFUCHSIA = PFN_vkCreateBufferCollectionFUCHSIA(
         vkGetDeviceProcAddr(device, "vkCreateBufferCollectionFUCHSIA"));
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+    vkCreateBufferCollectionFUCHSIAX = PFN_vkCreateBufferCollectionFUCHSIAX(
+        vkGetDeviceProcAddr(device, "vkCreateBufferCollectionFUCHSIAX"));
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
     vkCreateBufferView = PFN_vkCreateBufferView(
         vkGetDeviceProcAddr(device, "vkCreateBufferView"));
     vkCreateCommandPool = PFN_vkCreateCommandPool(
@@ -122487,11 +125334,11 @@
         vkGetDeviceProcAddr(device, "vkCreateDescriptorPool"));
     vkCreateDescriptorSetLayout = PFN_vkCreateDescriptorSetLayout(
         vkGetDeviceProcAddr(device, "vkCreateDescriptorSetLayout"));
+    vkCreateDescriptorUpdateTemplate = PFN_vkCreateDescriptorUpdateTemplate(
+        vkGetDeviceProcAddr(device, "vkCreateDescriptorUpdateTemplate"));
     vkCreateDescriptorUpdateTemplateKHR =
         PFN_vkCreateDescriptorUpdateTemplateKHR(
             vkGetDeviceProcAddr(device, "vkCreateDescriptorUpdateTemplateKHR"));
-    vkCreateDescriptorUpdateTemplate = PFN_vkCreateDescriptorUpdateTemplate(
-        vkGetDeviceProcAddr(device, "vkCreateDescriptorUpdateTemplate"));
     if (!vkCreateDescriptorUpdateTemplate)
       vkCreateDescriptorUpdateTemplate = vkCreateDescriptorUpdateTemplateKHR;
     vkCreateEvent =
@@ -122522,18 +125369,18 @@
         vkGetDeviceProcAddr(device, "vkCreateRayTracingPipelinesNV"));
     vkCreateRenderPass = PFN_vkCreateRenderPass(
         vkGetDeviceProcAddr(device, "vkCreateRenderPass"));
-    vkCreateRenderPass2KHR = PFN_vkCreateRenderPass2KHR(
-        vkGetDeviceProcAddr(device, "vkCreateRenderPass2KHR"));
     vkCreateRenderPass2 = PFN_vkCreateRenderPass2(
         vkGetDeviceProcAddr(device, "vkCreateRenderPass2"));
+    vkCreateRenderPass2KHR = PFN_vkCreateRenderPass2KHR(
+        vkGetDeviceProcAddr(device, "vkCreateRenderPass2KHR"));
     if (!vkCreateRenderPass2)
       vkCreateRenderPass2 = vkCreateRenderPass2KHR;
     vkCreateSampler =
         PFN_vkCreateSampler(vkGetDeviceProcAddr(device, "vkCreateSampler"));
-    vkCreateSamplerYcbcrConversionKHR = PFN_vkCreateSamplerYcbcrConversionKHR(
-        vkGetDeviceProcAddr(device, "vkCreateSamplerYcbcrConversionKHR"));
     vkCreateSamplerYcbcrConversion = PFN_vkCreateSamplerYcbcrConversion(
         vkGetDeviceProcAddr(device, "vkCreateSamplerYcbcrConversion"));
+    vkCreateSamplerYcbcrConversionKHR = PFN_vkCreateSamplerYcbcrConversionKHR(
+        vkGetDeviceProcAddr(device, "vkCreateSamplerYcbcrConversionKHR"));
     if (!vkCreateSamplerYcbcrConversion)
       vkCreateSamplerYcbcrConversion = vkCreateSamplerYcbcrConversionKHR;
     vkCreateSemaphore =
@@ -122562,6 +125409,10 @@
     vkDestroyBufferCollectionFUCHSIA = PFN_vkDestroyBufferCollectionFUCHSIA(
         vkGetDeviceProcAddr(device, "vkDestroyBufferCollectionFUCHSIA"));
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+    vkDestroyBufferCollectionFUCHSIAX = PFN_vkDestroyBufferCollectionFUCHSIAX(
+        vkGetDeviceProcAddr(device, "vkDestroyBufferCollectionFUCHSIAX"));
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
     vkDestroyBufferView = PFN_vkDestroyBufferView(
         vkGetDeviceProcAddr(device, "vkDestroyBufferView"));
     vkDestroyCommandPool = PFN_vkDestroyCommandPool(
@@ -122572,11 +125423,11 @@
         vkGetDeviceProcAddr(device, "vkDestroyDescriptorPool"));
     vkDestroyDescriptorSetLayout = PFN_vkDestroyDescriptorSetLayout(
         vkGetDeviceProcAddr(device, "vkDestroyDescriptorSetLayout"));
+    vkDestroyDescriptorUpdateTemplate = PFN_vkDestroyDescriptorUpdateTemplate(
+        vkGetDeviceProcAddr(device, "vkDestroyDescriptorUpdateTemplate"));
     vkDestroyDescriptorUpdateTemplateKHR =
         PFN_vkDestroyDescriptorUpdateTemplateKHR(vkGetDeviceProcAddr(
             device, "vkDestroyDescriptorUpdateTemplateKHR"));
-    vkDestroyDescriptorUpdateTemplate = PFN_vkDestroyDescriptorUpdateTemplate(
-        vkGetDeviceProcAddr(device, "vkDestroyDescriptorUpdateTemplate"));
     if (!vkDestroyDescriptorUpdateTemplate)
       vkDestroyDescriptorUpdateTemplate = vkDestroyDescriptorUpdateTemplateKHR;
     vkDestroyDevice =
@@ -122607,10 +125458,10 @@
         vkGetDeviceProcAddr(device, "vkDestroyRenderPass"));
     vkDestroySampler =
         PFN_vkDestroySampler(vkGetDeviceProcAddr(device, "vkDestroySampler"));
-    vkDestroySamplerYcbcrConversionKHR = PFN_vkDestroySamplerYcbcrConversionKHR(
-        vkGetDeviceProcAddr(device, "vkDestroySamplerYcbcrConversionKHR"));
     vkDestroySamplerYcbcrConversion = PFN_vkDestroySamplerYcbcrConversion(
         vkGetDeviceProcAddr(device, "vkDestroySamplerYcbcrConversion"));
+    vkDestroySamplerYcbcrConversionKHR = PFN_vkDestroySamplerYcbcrConversionKHR(
+        vkGetDeviceProcAddr(device, "vkDestroySamplerYcbcrConversionKHR"));
     if (!vkDestroySamplerYcbcrConversion)
       vkDestroySamplerYcbcrConversion = vkDestroySamplerYcbcrConversionKHR;
     vkDestroySemaphore = PFN_vkDestroySemaphore(
@@ -122657,32 +125508,42 @@
             device, "vkGetBufferCollectionProperties2FUCHSIA"));
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 #if defined(VK_USE_PLATFORM_FUCHSIA)
+    vkGetBufferCollectionProperties2FUCHSIAX =
+        PFN_vkGetBufferCollectionProperties2FUCHSIAX(vkGetDeviceProcAddr(
+            device, "vkGetBufferCollectionProperties2FUCHSIAX"));
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+#if defined(VK_USE_PLATFORM_FUCHSIA)
     vkGetBufferCollectionPropertiesFUCHSIA =
         PFN_vkGetBufferCollectionPropertiesFUCHSIA(vkGetDeviceProcAddr(
             device, "vkGetBufferCollectionPropertiesFUCHSIA"));
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
-    vkGetBufferDeviceAddressEXT = PFN_vkGetBufferDeviceAddressEXT(
-        vkGetDeviceProcAddr(device, "vkGetBufferDeviceAddressEXT"));
-    vkGetBufferDeviceAddressKHR = PFN_vkGetBufferDeviceAddressKHR(
-        vkGetDeviceProcAddr(device, "vkGetBufferDeviceAddressKHR"));
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+    vkGetBufferCollectionPropertiesFUCHSIAX =
+        PFN_vkGetBufferCollectionPropertiesFUCHSIAX(vkGetDeviceProcAddr(
+            device, "vkGetBufferCollectionPropertiesFUCHSIAX"));
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
     vkGetBufferDeviceAddress = PFN_vkGetBufferDeviceAddress(
         vkGetDeviceProcAddr(device, "vkGetBufferDeviceAddress"));
-    if (!vkGetBufferDeviceAddress)
-      vkGetBufferDeviceAddress = vkGetBufferDeviceAddressKHR;
+    vkGetBufferDeviceAddressEXT = PFN_vkGetBufferDeviceAddressEXT(
+        vkGetDeviceProcAddr(device, "vkGetBufferDeviceAddressEXT"));
     if (!vkGetBufferDeviceAddress)
       vkGetBufferDeviceAddress = vkGetBufferDeviceAddressEXT;
+    vkGetBufferDeviceAddressKHR = PFN_vkGetBufferDeviceAddressKHR(
+        vkGetDeviceProcAddr(device, "vkGetBufferDeviceAddressKHR"));
+    if (!vkGetBufferDeviceAddress)
+      vkGetBufferDeviceAddress = vkGetBufferDeviceAddressKHR;
     vkGetBufferMemoryRequirements = PFN_vkGetBufferMemoryRequirements(
         vkGetDeviceProcAddr(device, "vkGetBufferMemoryRequirements"));
-    vkGetBufferMemoryRequirements2KHR = PFN_vkGetBufferMemoryRequirements2KHR(
-        vkGetDeviceProcAddr(device, "vkGetBufferMemoryRequirements2KHR"));
     vkGetBufferMemoryRequirements2 = PFN_vkGetBufferMemoryRequirements2(
         vkGetDeviceProcAddr(device, "vkGetBufferMemoryRequirements2"));
+    vkGetBufferMemoryRequirements2KHR = PFN_vkGetBufferMemoryRequirements2KHR(
+        vkGetDeviceProcAddr(device, "vkGetBufferMemoryRequirements2KHR"));
     if (!vkGetBufferMemoryRequirements2)
       vkGetBufferMemoryRequirements2 = vkGetBufferMemoryRequirements2KHR;
-    vkGetBufferOpaqueCaptureAddressKHR = PFN_vkGetBufferOpaqueCaptureAddressKHR(
-        vkGetDeviceProcAddr(device, "vkGetBufferOpaqueCaptureAddressKHR"));
     vkGetBufferOpaqueCaptureAddress = PFN_vkGetBufferOpaqueCaptureAddress(
         vkGetDeviceProcAddr(device, "vkGetBufferOpaqueCaptureAddress"));
+    vkGetBufferOpaqueCaptureAddressKHR = PFN_vkGetBufferOpaqueCaptureAddressKHR(
+        vkGetDeviceProcAddr(device, "vkGetBufferOpaqueCaptureAddressKHR"));
     if (!vkGetBufferOpaqueCaptureAddress)
       vkGetBufferOpaqueCaptureAddress = vkGetBufferOpaqueCaptureAddressKHR;
     vkGetCalibratedTimestampsEXT = PFN_vkGetCalibratedTimestampsEXT(
@@ -122692,21 +125553,21 @@
             device, "vkGetDeferredOperationMaxConcurrencyKHR"));
     vkGetDeferredOperationResultKHR = PFN_vkGetDeferredOperationResultKHR(
         vkGetDeviceProcAddr(device, "vkGetDeferredOperationResultKHR"));
-    vkGetDescriptorSetLayoutSupportKHR = PFN_vkGetDescriptorSetLayoutSupportKHR(
-        vkGetDeviceProcAddr(device, "vkGetDescriptorSetLayoutSupportKHR"));
     vkGetDescriptorSetLayoutSupport = PFN_vkGetDescriptorSetLayoutSupport(
         vkGetDeviceProcAddr(device, "vkGetDescriptorSetLayoutSupport"));
+    vkGetDescriptorSetLayoutSupportKHR = PFN_vkGetDescriptorSetLayoutSupportKHR(
+        vkGetDeviceProcAddr(device, "vkGetDescriptorSetLayoutSupportKHR"));
     if (!vkGetDescriptorSetLayoutSupport)
       vkGetDescriptorSetLayoutSupport = vkGetDescriptorSetLayoutSupportKHR;
     vkGetDeviceAccelerationStructureCompatibilityKHR =
         PFN_vkGetDeviceAccelerationStructureCompatibilityKHR(
             vkGetDeviceProcAddr(
                 device, "vkGetDeviceAccelerationStructureCompatibilityKHR"));
+    vkGetDeviceGroupPeerMemoryFeatures = PFN_vkGetDeviceGroupPeerMemoryFeatures(
+        vkGetDeviceProcAddr(device, "vkGetDeviceGroupPeerMemoryFeatures"));
     vkGetDeviceGroupPeerMemoryFeaturesKHR =
         PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR(vkGetDeviceProcAddr(
             device, "vkGetDeviceGroupPeerMemoryFeaturesKHR"));
-    vkGetDeviceGroupPeerMemoryFeatures = PFN_vkGetDeviceGroupPeerMemoryFeatures(
-        vkGetDeviceProcAddr(device, "vkGetDeviceGroupPeerMemoryFeatures"));
     if (!vkGetDeviceGroupPeerMemoryFeatures)
       vkGetDeviceGroupPeerMemoryFeatures =
           vkGetDeviceGroupPeerMemoryFeaturesKHR;
@@ -122723,12 +125584,12 @@
             device, "vkGetDeviceGroupSurfacePresentModesKHR"));
     vkGetDeviceMemoryCommitment = PFN_vkGetDeviceMemoryCommitment(
         vkGetDeviceProcAddr(device, "vkGetDeviceMemoryCommitment"));
-    vkGetDeviceMemoryOpaqueCaptureAddressKHR =
-        PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR(vkGetDeviceProcAddr(
-            device, "vkGetDeviceMemoryOpaqueCaptureAddressKHR"));
     vkGetDeviceMemoryOpaqueCaptureAddress =
         PFN_vkGetDeviceMemoryOpaqueCaptureAddress(vkGetDeviceProcAddr(
             device, "vkGetDeviceMemoryOpaqueCaptureAddress"));
+    vkGetDeviceMemoryOpaqueCaptureAddressKHR =
+        PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR(vkGetDeviceProcAddr(
+            device, "vkGetDeviceMemoryOpaqueCaptureAddressKHR"));
     if (!vkGetDeviceMemoryOpaqueCaptureAddress)
       vkGetDeviceMemoryOpaqueCaptureAddress =
           vkGetDeviceMemoryOpaqueCaptureAddressKHR;
@@ -122756,20 +125617,20 @@
             device, "vkGetImageDrmFormatModifierPropertiesEXT"));
     vkGetImageMemoryRequirements = PFN_vkGetImageMemoryRequirements(
         vkGetDeviceProcAddr(device, "vkGetImageMemoryRequirements"));
-    vkGetImageMemoryRequirements2KHR = PFN_vkGetImageMemoryRequirements2KHR(
-        vkGetDeviceProcAddr(device, "vkGetImageMemoryRequirements2KHR"));
     vkGetImageMemoryRequirements2 = PFN_vkGetImageMemoryRequirements2(
         vkGetDeviceProcAddr(device, "vkGetImageMemoryRequirements2"));
+    vkGetImageMemoryRequirements2KHR = PFN_vkGetImageMemoryRequirements2KHR(
+        vkGetDeviceProcAddr(device, "vkGetImageMemoryRequirements2KHR"));
     if (!vkGetImageMemoryRequirements2)
       vkGetImageMemoryRequirements2 = vkGetImageMemoryRequirements2KHR;
     vkGetImageSparseMemoryRequirements = PFN_vkGetImageSparseMemoryRequirements(
         vkGetDeviceProcAddr(device, "vkGetImageSparseMemoryRequirements"));
-    vkGetImageSparseMemoryRequirements2KHR =
-        PFN_vkGetImageSparseMemoryRequirements2KHR(vkGetDeviceProcAddr(
-            device, "vkGetImageSparseMemoryRequirements2KHR"));
     vkGetImageSparseMemoryRequirements2 =
         PFN_vkGetImageSparseMemoryRequirements2(
             vkGetDeviceProcAddr(device, "vkGetImageSparseMemoryRequirements2"));
+    vkGetImageSparseMemoryRequirements2KHR =
+        PFN_vkGetImageSparseMemoryRequirements2KHR(vkGetDeviceProcAddr(
+            device, "vkGetImageSparseMemoryRequirements2KHR"));
     if (!vkGetImageSparseMemoryRequirements2)
       vkGetImageSparseMemoryRequirements2 =
           vkGetImageSparseMemoryRequirements2KHR;
@@ -122841,12 +125702,12 @@
         PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(
             vkGetDeviceProcAddr(
                 device, "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR"));
-    vkGetRayTracingShaderGroupHandlesNV =
-        PFN_vkGetRayTracingShaderGroupHandlesNV(
-            vkGetDeviceProcAddr(device, "vkGetRayTracingShaderGroupHandlesNV"));
     vkGetRayTracingShaderGroupHandlesKHR =
         PFN_vkGetRayTracingShaderGroupHandlesKHR(vkGetDeviceProcAddr(
             device, "vkGetRayTracingShaderGroupHandlesKHR"));
+    vkGetRayTracingShaderGroupHandlesNV =
+        PFN_vkGetRayTracingShaderGroupHandlesNV(
+            vkGetDeviceProcAddr(device, "vkGetRayTracingShaderGroupHandlesNV"));
     if (!vkGetRayTracingShaderGroupHandlesKHR)
       vkGetRayTracingShaderGroupHandlesKHR =
           vkGetRayTracingShaderGroupHandlesNV;
@@ -122857,10 +125718,10 @@
         vkGetDeviceProcAddr(device, "vkGetRefreshCycleDurationGOOGLE"));
     vkGetRenderAreaGranularity = PFN_vkGetRenderAreaGranularity(
         vkGetDeviceProcAddr(device, "vkGetRenderAreaGranularity"));
-    vkGetSemaphoreCounterValueKHR = PFN_vkGetSemaphoreCounterValueKHR(
-        vkGetDeviceProcAddr(device, "vkGetSemaphoreCounterValueKHR"));
     vkGetSemaphoreCounterValue = PFN_vkGetSemaphoreCounterValue(
         vkGetDeviceProcAddr(device, "vkGetSemaphoreCounterValue"));
+    vkGetSemaphoreCounterValueKHR = PFN_vkGetSemaphoreCounterValueKHR(
+        vkGetDeviceProcAddr(device, "vkGetSemaphoreCounterValueKHR"));
     if (!vkGetSemaphoreCounterValue)
       vkGetSemaphoreCounterValue = vkGetSemaphoreCounterValueKHR;
     vkGetSemaphoreFdKHR = PFN_vkGetSemaphoreFdKHR(
@@ -122956,10 +125817,10 @@
         PFN_vkResetEvent(vkGetDeviceProcAddr(device, "vkResetEvent"));
     vkResetFences =
         PFN_vkResetFences(vkGetDeviceProcAddr(device, "vkResetFences"));
-    vkResetQueryPoolEXT = PFN_vkResetQueryPoolEXT(
-        vkGetDeviceProcAddr(device, "vkResetQueryPoolEXT"));
     vkResetQueryPool =
         PFN_vkResetQueryPool(vkGetDeviceProcAddr(device, "vkResetQueryPool"));
+    vkResetQueryPoolEXT = PFN_vkResetQueryPoolEXT(
+        vkGetDeviceProcAddr(device, "vkResetQueryPoolEXT"));
     if (!vkResetQueryPool)
       vkResetQueryPool = vkResetQueryPoolEXT;
 #if defined(VK_USE_PLATFORM_FUCHSIA)
@@ -122968,15 +125829,30 @@
             device, "vkSetBufferCollectionBufferConstraintsFUCHSIA"));
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 #if defined(VK_USE_PLATFORM_FUCHSIA)
+    vkSetBufferCollectionBufferConstraintsFUCHSIAX =
+        PFN_vkSetBufferCollectionBufferConstraintsFUCHSIAX(vkGetDeviceProcAddr(
+            device, "vkSetBufferCollectionBufferConstraintsFUCHSIAX"));
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+#if defined(VK_USE_PLATFORM_FUCHSIA)
     vkSetBufferCollectionConstraintsFUCHSIA =
         PFN_vkSetBufferCollectionConstraintsFUCHSIA(vkGetDeviceProcAddr(
             device, "vkSetBufferCollectionConstraintsFUCHSIA"));
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 #if defined(VK_USE_PLATFORM_FUCHSIA)
+    vkSetBufferCollectionConstraintsFUCHSIAX =
+        PFN_vkSetBufferCollectionConstraintsFUCHSIAX(vkGetDeviceProcAddr(
+            device, "vkSetBufferCollectionConstraintsFUCHSIAX"));
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+#if defined(VK_USE_PLATFORM_FUCHSIA)
     vkSetBufferCollectionImageConstraintsFUCHSIA =
         PFN_vkSetBufferCollectionImageConstraintsFUCHSIA(vkGetDeviceProcAddr(
             device, "vkSetBufferCollectionImageConstraintsFUCHSIA"));
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+    vkSetBufferCollectionImageConstraintsFUCHSIAX =
+        PFN_vkSetBufferCollectionImageConstraintsFUCHSIAX(vkGetDeviceProcAddr(
+            device, "vkSetBufferCollectionImageConstraintsFUCHSIAX"));
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
     vkSetDebugUtilsObjectNameEXT = PFN_vkSetDebugUtilsObjectNameEXT(
         vkGetDeviceProcAddr(device, "vkSetDebugUtilsObjectNameEXT"));
     vkSetDebugUtilsObjectTagEXT = PFN_vkSetDebugUtilsObjectTagEXT(
@@ -122988,16 +125864,16 @@
         vkGetDeviceProcAddr(device, "vkSetLocalDimmingAMD"));
     vkSetPrivateDataEXT = PFN_vkSetPrivateDataEXT(
         vkGetDeviceProcAddr(device, "vkSetPrivateDataEXT"));
-    vkSignalSemaphoreKHR = PFN_vkSignalSemaphoreKHR(
-        vkGetDeviceProcAddr(device, "vkSignalSemaphoreKHR"));
     vkSignalSemaphore =
         PFN_vkSignalSemaphore(vkGetDeviceProcAddr(device, "vkSignalSemaphore"));
+    vkSignalSemaphoreKHR = PFN_vkSignalSemaphoreKHR(
+        vkGetDeviceProcAddr(device, "vkSignalSemaphoreKHR"));
     if (!vkSignalSemaphore)
       vkSignalSemaphore = vkSignalSemaphoreKHR;
-    vkTrimCommandPoolKHR = PFN_vkTrimCommandPoolKHR(
-        vkGetDeviceProcAddr(device, "vkTrimCommandPoolKHR"));
     vkTrimCommandPool =
         PFN_vkTrimCommandPool(vkGetDeviceProcAddr(device, "vkTrimCommandPool"));
+    vkTrimCommandPoolKHR = PFN_vkTrimCommandPoolKHR(
+        vkGetDeviceProcAddr(device, "vkTrimCommandPoolKHR"));
     if (!vkTrimCommandPool)
       vkTrimCommandPool = vkTrimCommandPoolKHR;
 #if defined(VK_USE_PLATFORM_FUCHSIA)
@@ -123009,21 +125885,21 @@
         vkGetDeviceProcAddr(device, "vkUninitializePerformanceApiINTEL"));
     vkUnmapMemory =
         PFN_vkUnmapMemory(vkGetDeviceProcAddr(device, "vkUnmapMemory"));
+    vkUpdateDescriptorSetWithTemplate = PFN_vkUpdateDescriptorSetWithTemplate(
+        vkGetDeviceProcAddr(device, "vkUpdateDescriptorSetWithTemplate"));
     vkUpdateDescriptorSetWithTemplateKHR =
         PFN_vkUpdateDescriptorSetWithTemplateKHR(vkGetDeviceProcAddr(
             device, "vkUpdateDescriptorSetWithTemplateKHR"));
-    vkUpdateDescriptorSetWithTemplate = PFN_vkUpdateDescriptorSetWithTemplate(
-        vkGetDeviceProcAddr(device, "vkUpdateDescriptorSetWithTemplate"));
     if (!vkUpdateDescriptorSetWithTemplate)
       vkUpdateDescriptorSetWithTemplate = vkUpdateDescriptorSetWithTemplateKHR;
     vkUpdateDescriptorSets = PFN_vkUpdateDescriptorSets(
         vkGetDeviceProcAddr(device, "vkUpdateDescriptorSets"));
     vkWaitForFences =
         PFN_vkWaitForFences(vkGetDeviceProcAddr(device, "vkWaitForFences"));
-    vkWaitSemaphoresKHR = PFN_vkWaitSemaphoresKHR(
-        vkGetDeviceProcAddr(device, "vkWaitSemaphoresKHR"));
     vkWaitSemaphores =
         PFN_vkWaitSemaphores(vkGetDeviceProcAddr(device, "vkWaitSemaphores"));
+    vkWaitSemaphoresKHR = PFN_vkWaitSemaphoresKHR(
+        vkGetDeviceProcAddr(device, "vkWaitSemaphoresKHR"));
     if (!vkWaitSemaphores)
       vkWaitSemaphores = vkWaitSemaphoresKHR;
     vkWriteAccelerationStructuresPropertiesKHR =
@@ -123072,6 +125948,17 @@
 };
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+template <> struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIAX> {
+  std::size_t
+  operator()(VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIAX const
+                 &bufferCollectionFUCHSIAX) const VULKAN_HPP_NOEXCEPT {
+    return std::hash<VkBufferCollectionFUCHSIAX>{}(
+        static_cast<VkBufferCollectionFUCHSIAX>(bufferCollectionFUCHSIAX));
+  }
+};
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+
 template <> struct hash<VULKAN_HPP_NAMESPACE::BufferView> {
   std::size_t operator()(VULKAN_HPP_NAMESPACE::BufferView const &bufferView)
       const VULKAN_HPP_NOEXCEPT {
diff --git a/include/vulkan/vulkan_core.h b/include/vulkan/vulkan_core.h
index 54091aa..a7f2535 100644
--- a/include/vulkan/vulkan_core.h
+++ b/include/vulkan/vulkan_core.h
@@ -680,6 +680,16 @@
     VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA = 1000364002,
     VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA = 1000365000,
     VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA = 1000365001,
+    VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIAX = 1000367000,
+    VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIAX = 1000367004,
+    VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIAX = 1000367005,
+    VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIAX = 1000367006,
+    VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIAX = 1000367007,
+    VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIAX = 1000367008,
+    VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIAX = 1000367009,
+    VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIAX = 1000367010,
+    VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES2_FUCHSIAX = 1000367011,
+    VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIAX = 1000367012,
     VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX = 1000378000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES,
@@ -873,6 +883,7 @@
     VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV = 1000277000,
     VK_OBJECT_TYPE_PRIVATE_DATA_SLOT_EXT = 1000295000,
     VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA = 1001004002,
+    VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIAX = 1000367002,
     VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE,
     VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION,
     VK_OBJECT_TYPE_MAX_ENUM = 0x7FFFFFFF
@@ -8055,6 +8066,7 @@
     VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR_EXT = 1000150000,
     VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT = 1000165000,
     VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA_EXT = 1001004003,
+    VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIAX_EXT = 1000367003,
     VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT,
     VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT,
     VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT,
diff --git a/include/vulkan/vulkan_fuchsia.h b/include/vulkan/vulkan_fuchsia.h
index bfbb874..a13a404 100644
--- a/include/vulkan/vulkan_fuchsia.h
+++ b/include/vulkan/vulkan_fuchsia.h
@@ -115,6 +115,160 @@
 #endif
 
 
+#define VK_FUCHSIA_buffer_collection_x 1
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferCollectionFUCHSIAX)
+#define VK_FUCHSIA_BUFFER_COLLECTION_X_SPEC_VERSION 1
+#define VK_FUCHSIA_BUFFER_COLLECTION_X_EXTENSION_NAME "VK_FUCHSIA_buffer_collection_x"
+
+typedef enum VkImageFormatConstraintsFlagBitsFUCHSIAX {
+    VK_IMAGE_FORMAT_CONSTRAINTS_FLAG_BITS_MAX_ENUM_FUCHSIAX = 0x7FFFFFFF
+} VkImageFormatConstraintsFlagBitsFUCHSIAX;
+typedef VkFlags VkImageFormatConstraintsFlagsFUCHSIAX;
+
+typedef enum VkImageConstraintsInfoFlagBitsFUCHSIAX {
+    VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_RARELY_FUCHSIAX = 0x00000001,
+    VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_OFTEN_FUCHSIAX = 0x00000002,
+    VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_RARELY_FUCHSIAX = 0x00000004,
+    VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_OFTEN_FUCHSIAX = 0x00000008,
+    VK_IMAGE_CONSTRAINTS_INFO_PROTECTED_OPTIONAL_FUCHSIAX = 0x00000010,
+    VK_IMAGE_CONSTRAINTS_INFO_FLAG_BITS_MAX_ENUM_FUCHSIAX = 0x7FFFFFFF
+} VkImageConstraintsInfoFlagBitsFUCHSIAX;
+typedef VkFlags VkImageConstraintsInfoFlagsFUCHSIAX;
+typedef struct VkBufferCollectionCreateInfoFUCHSIAX {
+    VkStructureType    sType;
+    const void*        pNext;
+    zx_handle_t        collectionToken;
+} VkBufferCollectionCreateInfoFUCHSIAX;
+
+typedef struct VkImportMemoryBufferCollectionFUCHSIAX {
+    VkStructureType               sType;
+    const void*                   pNext;
+    VkBufferCollectionFUCHSIAX    collection;
+    uint32_t                      index;
+} VkImportMemoryBufferCollectionFUCHSIAX;
+
+typedef struct VkBufferCollectionImageCreateInfoFUCHSIAX {
+    VkStructureType               sType;
+    const void*                   pNext;
+    VkBufferCollectionFUCHSIAX    collection;
+    uint32_t                      index;
+} VkBufferCollectionImageCreateInfoFUCHSIAX;
+
+typedef struct VkBufferConstraintsInfoFUCHSIAX {
+    VkStructureType              sType;
+    const void*                  pNext;
+    const VkBufferCreateInfo*    pBufferCreateInfo;
+    VkFormatFeatureFlags         requiredFormatFeatures;
+    uint32_t                     minCount;
+} VkBufferConstraintsInfoFUCHSIAX;
+
+typedef struct VkBufferCollectionBufferCreateInfoFUCHSIAX {
+    VkStructureType               sType;
+    const void*                   pNext;
+    VkBufferCollectionFUCHSIAX    collection;
+    uint32_t                      index;
+} VkBufferCollectionBufferCreateInfoFUCHSIAX;
+
+typedef struct VkBufferCollectionPropertiesFUCHSIAX {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           memoryTypeBits;
+    uint32_t           count;
+} VkBufferCollectionPropertiesFUCHSIAX;
+
+typedef struct VkSysmemColorSpaceFUCHSIAX {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint32_t           colorSpace;
+} VkSysmemColorSpaceFUCHSIAX;
+
+typedef struct VkBufferCollectionProperties2FUCHSIAX {
+    VkStructureType                  sType;
+    void*                            pNext;
+    uint32_t                         memoryTypeBits;
+    uint32_t                         bufferCount;
+    uint32_t                         createInfoIndex;
+    uint64_t                         sysmemFormat;
+    VkFormatFeatureFlags             formatFeatures;
+    VkSysmemColorSpaceFUCHSIAX       colorSpace;
+    VkComponentMapping               samplerYcbcrConversionComponents;
+    VkSamplerYcbcrModelConversion    suggestedYcbcrModel;
+    VkSamplerYcbcrRange              suggestedYcbcrRange;
+    VkChromaLocation                 suggestedXChromaOffset;
+    VkChromaLocation                 suggestedYChromaOffset;
+} VkBufferCollectionProperties2FUCHSIAX;
+
+typedef struct VkImageFormatConstraintsInfoFUCHSIAX {
+    VkStructureType                          sType;
+    const void*                              pNext;
+    VkFormatFeatureFlags                     requiredFormatFeatures;
+    VkImageFormatConstraintsFlagsFUCHSIAX    flags;
+    uint64_t                                 sysmemFormat;
+    uint32_t                                 colorSpaceCount;
+    const VkSysmemColorSpaceFUCHSIAX*        pColorSpaces;
+} VkImageFormatConstraintsInfoFUCHSIAX;
+
+typedef struct VkImageConstraintsInfoFUCHSIAX {
+    VkStructureType                                sType;
+    const void*                                    pNext;
+    uint32_t                                       createInfoCount;
+    const VkImageCreateInfo*                       pCreateInfos;
+    const VkImageFormatConstraintsInfoFUCHSIAX*    pFormatConstraints;
+    uint32_t                                       minBufferCount;
+    uint32_t                                       maxBufferCount;
+    uint32_t                                       minBufferCountForCamping;
+    uint32_t                                       minBufferCountForDedicatedSlack;
+    uint32_t                                       minBufferCountForSharedSlack;
+    VkImageConstraintsInfoFlagsFUCHSIAX            flags;
+} VkImageConstraintsInfoFUCHSIAX;
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateBufferCollectionFUCHSIAX)(VkDevice device, const VkBufferCollectionCreateInfoFUCHSIAX* pImportInfo, const VkAllocationCallbacks* pAllocator, VkBufferCollectionFUCHSIAX* pCollection);
+typedef VkResult (VKAPI_PTR *PFN_vkSetBufferCollectionConstraintsFUCHSIAX)(VkDevice device, VkBufferCollectionFUCHSIAX collection, const VkImageCreateInfo* pImageInfo);
+typedef VkResult (VKAPI_PTR *PFN_vkSetBufferCollectionImageConstraintsFUCHSIAX)(VkDevice device, VkBufferCollectionFUCHSIAX collection, const VkImageConstraintsInfoFUCHSIAX* pImageConstraintsInfo);
+typedef VkResult (VKAPI_PTR *PFN_vkSetBufferCollectionBufferConstraintsFUCHSIAX)(VkDevice device, VkBufferCollectionFUCHSIAX collection, const VkBufferConstraintsInfoFUCHSIAX* pBufferConstraintsInfo);
+typedef void (VKAPI_PTR *PFN_vkDestroyBufferCollectionFUCHSIAX)(VkDevice device, VkBufferCollectionFUCHSIAX collection, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI_PTR *PFN_vkGetBufferCollectionPropertiesFUCHSIAX)(VkDevice device, VkBufferCollectionFUCHSIAX collection, VkBufferCollectionPropertiesFUCHSIAX* pProperties);
+typedef VkResult (VKAPI_PTR *PFN_vkGetBufferCollectionProperties2FUCHSIAX)(VkDevice device, VkBufferCollectionFUCHSIAX collection, VkBufferCollectionProperties2FUCHSIAX* pProperties);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferCollectionFUCHSIAX(
+    VkDevice                                    device,
+    const VkBufferCollectionCreateInfoFUCHSIAX* pImportInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkBufferCollectionFUCHSIAX*                 pCollection);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkSetBufferCollectionConstraintsFUCHSIAX(
+    VkDevice                                    device,
+    VkBufferCollectionFUCHSIAX                  collection,
+    const VkImageCreateInfo*                    pImageInfo);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkSetBufferCollectionImageConstraintsFUCHSIAX(
+    VkDevice                                    device,
+    VkBufferCollectionFUCHSIAX                  collection,
+    const VkImageConstraintsInfoFUCHSIAX*       pImageConstraintsInfo);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkSetBufferCollectionBufferConstraintsFUCHSIAX(
+    VkDevice                                    device,
+    VkBufferCollectionFUCHSIAX                  collection,
+    const VkBufferConstraintsInfoFUCHSIAX*      pBufferConstraintsInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyBufferCollectionFUCHSIAX(
+    VkDevice                                    device,
+    VkBufferCollectionFUCHSIAX                  collection,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetBufferCollectionPropertiesFUCHSIAX(
+    VkDevice                                    device,
+    VkBufferCollectionFUCHSIAX                  collection,
+    VkBufferCollectionPropertiesFUCHSIAX*       pProperties);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetBufferCollectionProperties2FUCHSIAX(
+    VkDevice                                    device,
+    VkBufferCollectionFUCHSIAX                  collection,
+    VkBufferCollectionProperties2FUCHSIAX*      pProperties);
+#endif
+
+
 #define VK_FUCHSIA_buffer_collection 1
 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferCollectionFUCHSIA)
 #define VK_FUCHSIA_BUFFER_COLLECTION_SPEC_VERSION 1
diff --git a/registry/vk.xml b/registry/vk.xml
index ceecae5..618232a 100644
--- a/registry/vk.xml
+++ b/registry/vk.xml
@@ -366,7 +366,9 @@
         <type requires="VkSwapchainImageUsageFlagBitsANDROID" category="bitmask">typedef <type>VkFlags</type> <name>VkSwapchainImageUsageFlagsANDROID</name>;</type>
         <type requires="VkToolPurposeFlagBitsEXT"         category="bitmask">typedef <type>VkFlags</type> <name>VkToolPurposeFlagsEXT</name>;</type>
         <type requires="VkImageFormatConstraintsFlagBitsFUCHSIA"     category="bitmask">typedef <type>VkFlags</type> <name>VkImageFormatConstraintsFlagsFUCHSIA</name>;</type>
+        <type requires="VkImageFormatConstraintsFlagBitsFUCHSIAX"     category="bitmask">typedef <type>VkFlags</type> <name>VkImageFormatConstraintsFlagsFUCHSIAX</name>;</type>
         <type requires="VkImageConstraintsInfoFlagBitsFUCHSIA"     category="bitmask">typedef <type>VkFlags</type> <name>VkImageConstraintsInfoFlagsFUCHSIA</name>;</type>
+        <type requires="VkImageConstraintsInfoFlagBitsFUCHSIAX"     category="bitmask">typedef <type>VkFlags</type> <name>VkImageConstraintsInfoFlagsFUCHSIAX</name>;</type>
         <type requires="VkMemoryOpFlagBitsFUCHSIA"     category="bitmask">typedef <type>VkFlags</type> <name>VkMemoryOpFlagsFUCHSIA</name>;</type>
         <type requires="VkSubmitFlagBitsKHR"              category="bitmask">typedef <type>VkFlags</type> <name>VkSubmitFlagsKHR</name>;</type>
 
@@ -402,6 +404,7 @@
         <type category="handle" parent="VkDevice"         objtypeenum="VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkSamplerYcbcrConversion</name>)</type>
         <type category="handle" name="VkSamplerYcbcrConversionKHR"   alias="VkSamplerYcbcrConversion"/>
         <type category="handle" parent="VkDevice"         objtypeenum="VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkBufferCollectionFUCHSIA</name>)</type>
+        <type category="handle" parent="VkDevice"         objtypeenum="VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIAX"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkBufferCollectionFUCHSIAX</name>)</type>
         <type category="handle" parent="VkDevice"         objtypeenum="VK_OBJECT_TYPE_VALIDATION_CACHE_EXT"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkValidationCacheEXT</name>)</type>
         <type category="handle" parent="VkDevice"         objtypeenum="VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkAccelerationStructureKHR</name>)</type>
         <type category="handle" parent="VkDevice"         objtypeenum="VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkAccelerationStructureNV</name>)</type>
@@ -567,7 +570,9 @@
         <type name="VkShaderCorePropertiesFlagBitsAMD" category="enum"/>
         <type name="VkToolPurposeFlagBitsEXT" category="enum"/>
         <type name="VkImageFormatConstraintsFlagBitsFUCHSIA" category="enum"/>
+        <type name="VkImageFormatConstraintsFlagBitsFUCHSIAX" category="enum"/>
         <type name="VkImageConstraintsInfoFlagBitsFUCHSIA" category="enum"/>
+        <type name="VkImageConstraintsInfoFlagBitsFUCHSIAX" category="enum"/>
         <type name="VkMemoryOpFlagBitsFUCHSIA" category="enum"/>
         <type name="VkFragmentShadingRateNV" category="enum"/>
         <type name="VkFragmentShadingRateTypeNV" category="enum"/>
@@ -2286,29 +2291,58 @@
             <member><type>VkBufferCollectionFUCHSIA</type>        <name>collection</name></member>
             <member><type>uint32_t</type>                         <name>index</name></member>
         </type>
+        <type category="struct" name="VkImportMemoryBufferCollectionFUCHSIAX" structextends="VkMemoryAllocateInfo">
+            <member values="VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIAX"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*                      <name>pNext</name></member>
+            <member><type>VkBufferCollectionFUCHSIAX</type>        <name>collection</name></member>
+            <member><type>uint32_t</type>                         <name>index</name></member>
+        </type>
         <type category="struct" name="VkBufferCollectionImageCreateInfoFUCHSIA" structextends="VkImageCreateInfo">
             <member values="VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA"><type>VkStructureType</type> <name>sType</name></member>
             <member>const <type>void</type>*                      <name>pNext</name></member>
             <member><type>VkBufferCollectionFUCHSIA</type>        <name>collection</name></member>
             <member><type>uint32_t</type>                         <name>index</name></member>
         </type>
+        <type category="struct" name="VkBufferCollectionImageCreateInfoFUCHSIAX" structextends="VkImageCreateInfo">
+            <member values="VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIAX"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*                      <name>pNext</name></member>
+            <member><type>VkBufferCollectionFUCHSIAX</type>        <name>collection</name></member>
+            <member><type>uint32_t</type>                         <name>index</name></member>
+        </type>
         <type category="struct" name="VkBufferCollectionBufferCreateInfoFUCHSIA" structextends="VkBufferCreateInfo">
             <member values="VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA"><type>VkStructureType</type> <name>sType</name></member>
             <member>const <type>void</type>*                      <name>pNext</name></member>
             <member><type>VkBufferCollectionFUCHSIA</type>        <name>collection</name></member>
             <member><type>uint32_t</type>                         <name>index</name></member>
         </type>
+        <type category="struct" name="VkBufferCollectionBufferCreateInfoFUCHSIAX" structextends="VkBufferCreateInfo">
+            <member values="VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIAX"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*                      <name>pNext</name></member>
+            <member><type>VkBufferCollectionFUCHSIAX</type>        <name>collection</name></member>
+            <member><type>uint32_t</type>                         <name>index</name></member>
+        </type>
         <type category="struct" name="VkBufferCollectionCreateInfoFUCHSIA">
             <member values="VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA"><type>VkStructureType</type> <name>sType</name></member>
             <member>const <type>void</type>*                      <name>pNext</name></member>
             <member><type>zx_handle_t</type>                      <name>collectionToken</name></member>
         </type>
+        <type category="struct" name="VkBufferCollectionCreateInfoFUCHSIAX">
+            <member values="VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIAX"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*                      <name>pNext</name></member>
+            <member><type>zx_handle_t</type>                      <name>collectionToken</name></member>
+        </type>
         <type category="struct" name="VkBufferCollectionPropertiesFUCHSIA">
             <member values="VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA"><type>VkStructureType</type> <name>sType</name></member>
             <member><type>void</type>*                            <name>pNext</name></member>
             <member><type>uint32_t</type>                         <name>memoryTypeBits</name></member>
             <member><type>uint32_t</type>                         <name>count</name></member>
         </type>
+        <type category="struct" name="VkBufferCollectionPropertiesFUCHSIAX">
+            <member values="VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIAX"><type>VkStructureType</type> <name>sType</name></member>
+            <member><type>void</type>*                            <name>pNext</name></member>
+            <member><type>uint32_t</type>                         <name>memoryTypeBits</name></member>
+            <member><type>uint32_t</type>                         <name>count</name></member>
+        </type>
         <type category="struct" name="VkBufferCollectionProperties2FUCHSIA">
             <member values="VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES2_FUCHSIA"><type>VkStructureType</type> <name>sType</name></member>
             <member><type>void</type>*                            <name>pNext</name></member>
@@ -2324,6 +2358,21 @@
             <member><type>VkChromaLocation</type>                 <name>suggestedXChromaOffset</name></member>
             <member><type>VkChromaLocation</type>                 <name>suggestedYChromaOffset</name></member>
         </type>
+        <type category="struct" name="VkBufferCollectionProperties2FUCHSIAX">
+            <member values="VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES2_FUCHSIAX"><type>VkStructureType</type> <name>sType</name></member>
+            <member><type>void</type>*                            <name>pNext</name></member>
+            <member><type>uint32_t</type>                         <name>memoryTypeBits</name></member>
+            <member><type>uint32_t</type>                         <name>bufferCount</name></member>
+            <member><type>uint32_t</type>                         <name>createInfoIndex</name></member>
+            <member><type>uint64_t</type>                         <name>sysmemFormat</name></member>
+            <member><type>VkFormatFeatureFlags</type>             <name>formatFeatures</name></member>
+            <member><type>VkSysmemColorSpaceFUCHSIAX</type>        <name>colorSpace</name></member>
+            <member><type>VkComponentMapping</type>               <name>samplerYcbcrConversionComponents</name></member>
+            <member><type>VkSamplerYcbcrModelConversion</type>    <name>suggestedYcbcrModel</name></member>
+            <member><type>VkSamplerYcbcrRange</type>              <name>suggestedYcbcrRange</name></member>
+            <member><type>VkChromaLocation</type>                 <name>suggestedXChromaOffset</name></member>
+            <member><type>VkChromaLocation</type>                 <name>suggestedYChromaOffset</name></member>
+        </type>
         <type category="struct" name="VkBufferConstraintsInfoFUCHSIA">
             <member values="VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA"><type>VkStructureType</type> <name>sType</name></member>
             <member>const <type>void</type>*                      <name>pNext</name></member>
@@ -2331,11 +2380,23 @@
             <member optional="true"><type>VkFormatFeatureFlags</type>             <name>requiredFormatFeatures</name></member>
             <member><type>uint32_t</type>                         <name>minCount</name></member>
         </type>
+        <type category="struct" name="VkBufferConstraintsInfoFUCHSIAX">
+            <member values="VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIAX"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*                      <name>pNext</name></member>
+            <member>const <type>VkBufferCreateInfo</type>*        <name>pBufferCreateInfo</name></member>
+            <member optional="true"><type>VkFormatFeatureFlags</type>             <name>requiredFormatFeatures</name></member>
+            <member><type>uint32_t</type>                         <name>minCount</name></member>
+        </type>
         <type category="struct" name="VkSysmemColorSpaceFUCHSIA">
             <member values="VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA"><type>VkStructureType</type> <name>sType</name></member>
             <member>const <type>void</type>*                     <name>pNext</name></member>
             <member><type>uint32_t</type>                        <name>colorSpace</name></member>
         </type>
+        <type category="struct" name="VkSysmemColorSpaceFUCHSIAX">
+            <member values="VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIAX"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*                     <name>pNext</name></member>
+            <member><type>uint32_t</type>                        <name>colorSpace</name></member>
+        </type>
         <type category="struct" name="VkImageFormatConstraintsInfoFUCHSIA">
             <member values="VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA"><type>VkStructureType</type> <name>sType</name></member>
             <member>const <type>void</type>*                     <name>pNext</name></member>
@@ -2345,6 +2406,15 @@
             <member><type>uint32_t</type>                        <name>colorSpaceCount</name></member>
             <member optional="true">const <type>VkSysmemColorSpaceFUCHSIA</type>*      <name>pColorSpaces</name></member>
         </type>
+        <type category="struct" name="VkImageFormatConstraintsInfoFUCHSIAX">
+            <member values="VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIAX"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*                     <name>pNext</name></member>
+            <member optional="true"><type>VkFormatFeatureFlags</type>            <name>requiredFormatFeatures</name></member>
+            <member optional="true"><type>VkImageFormatConstraintsFlagsFUCHSIAX</type>       <name>flags</name></member>
+            <member><type>uint64_t</type>                        <name>sysmemFormat</name></member>
+            <member><type>uint32_t</type>                        <name>colorSpaceCount</name></member>
+            <member optional="true">const <type>VkSysmemColorSpaceFUCHSIAX</type>*      <name>pColorSpaces</name></member>
+        </type>
         <type category="struct" name="VkImageConstraintsInfoFUCHSIA">
             <member values="VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA"><type>VkStructureType</type> <name>sType</name></member>
             <member>const <type>void</type>*                     <name>pNext</name></member>
@@ -2358,6 +2428,19 @@
             <member><type>uint32_t</type>                        <name>minBufferCountForSharedSlack</name></member>
             <member optional="true"><type>VkImageConstraintsInfoFlagsFUCHSIA</type>       <name>flags</name></member>
         </type>
+        <type category="struct" name="VkImageConstraintsInfoFUCHSIAX">
+            <member values="VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIAX"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*                     <name>pNext</name></member>
+            <member><type>uint32_t</type>                        <name>createInfoCount</name></member>
+            <member len="createInfoCount">const <type>VkImageCreateInfo</type>*  <name>pCreateInfos</name></member>
+            <member len="createInfoCount" optional="true">const <type>VkImageFormatConstraintsInfoFUCHSIAX</type>* <name>pFormatConstraints</name></member>
+            <member><type>uint32_t</type>                        <name>minBufferCount</name></member>
+            <member><type>uint32_t</type>                        <name>maxBufferCount</name></member>
+            <member><type>uint32_t</type>                        <name>minBufferCountForCamping</name></member>
+            <member><type>uint32_t</type>                        <name>minBufferCountForDedicatedSlack</name></member>
+            <member><type>uint32_t</type>                        <name>minBufferCountForSharedSlack</name></member>
+            <member optional="true"><type>VkImageConstraintsInfoFlagsFUCHSIAX</type>       <name>flags</name></member>
+        </type>
         <type category="struct" name="VkMemoryWin32HandlePropertiesKHR" returnedonly="true">
             <member values="VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR"><type>VkStructureType</type> <name>sType</name></member>
             <member optional="true"><type>void</type>*                            <name>pNext</name></member>
@@ -6808,6 +6891,8 @@
     </enums>
     <enums name="VkImageFormatConstraintsFlagBitsFUCHSIA" type="bitmask">
     </enums>
+    <enums name="VkImageFormatConstraintsFlagBitsFUCHSIAX" type="bitmask">
+    </enums>
     <enums name="VkImageConstraintsInfoFlagBitsFUCHSIA" type="bitmask">
         <enum bitpos="0"    name="VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_RARELY_FUCHSIA"/>
         <enum bitpos="1"    name="VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_OFTEN_FUCHSIA"/>
@@ -6815,6 +6900,13 @@
         <enum bitpos="3"    name="VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_OFTEN_FUCHSIA"/>
         <enum bitpos="4"    name="VK_IMAGE_CONSTRAINTS_INFO_PROTECTED_OPTIONAL_FUCHSIA"/>
     </enums>
+    <enums name="VkImageConstraintsInfoFlagBitsFUCHSIAX" type="bitmask">
+        <enum bitpos="0"    name="VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_RARELY_FUCHSIAX"/>
+        <enum bitpos="1"    name="VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_OFTEN_FUCHSIAX"/>
+        <enum bitpos="2"    name="VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_RARELY_FUCHSIAX"/>
+        <enum bitpos="3"    name="VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_OFTEN_FUCHSIAX"/>
+        <enum bitpos="4"    name="VK_IMAGE_CONSTRAINTS_INFO_PROTECTED_OPTIONAL_FUCHSIAX"/>
+    </enums>
     <enums name="VkMemoryOpFlagBitsFUCHSIA" type="bitmask">
         <enum bitpos="0"    name="VK_MEMORY_OP_UNPIN_BIT_FUCHSIA"/>
         <enum bitpos="1"    name="VK_MEMORY_OP_DECOMMIT_BIT_FUCHSIA"/>
@@ -6823,7 +6915,6 @@
         <enum bitpos="4"    name="VK_MEMORY_OP_LOCK_BIT_FUCHSIA"/>
         <enum bitpos="5"    name="VK_MEMORY_OP_UNLOCK_BIT_FUCHSIA"/>
     </enums>
-
     <enums name="VkFragmentShadingRateCombinerOpKHR" type="enum">
         <enum value="0" name="VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR"/>
         <enum value="1" name="VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR"/>
@@ -8100,29 +8191,60 @@
             <param><type>VkBufferCollectionFUCHSIA</type>* <name>pCollection</name></param>
         </command>
         <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
+            <proto><type>VkResult</type> <name>vkCreateBufferCollectionFUCHSIAX</name></proto>
+            <param><type>VkDevice</type> <name>device</name></param>
+            <param>const <type>VkBufferCollectionCreateInfoFUCHSIAX</type>* <name>pImportInfo</name></param>
+            <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
+            <param><type>VkBufferCollectionFUCHSIAX</type>* <name>pCollection</name></param>
+        </command>
+        <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
             <proto><type>VkResult</type> <name>vkSetBufferCollectionConstraintsFUCHSIA</name></proto>
             <param><type>VkDevice</type> <name>device</name></param>
             <param><type>VkBufferCollectionFUCHSIA</type> <name>collection</name></param>
             <param>const <type>VkImageCreateInfo</type>* <name>pImageInfo</name></param>
         </command>
         <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
+            <proto><type>VkResult</type> <name>vkSetBufferCollectionConstraintsFUCHSIAX</name></proto>
+            <param><type>VkDevice</type> <name>device</name></param>
+            <param><type>VkBufferCollectionFUCHSIAX</type> <name>collection</name></param>
+            <param>const <type>VkImageCreateInfo</type>* <name>pImageInfo</name></param>
+        </command>
+        <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
             <proto><type>VkResult</type> <name>vkSetBufferCollectionBufferConstraintsFUCHSIA</name></proto>
             <param><type>VkDevice</type> <name>device</name></param>
             <param><type>VkBufferCollectionFUCHSIA</type> <name>collection</name></param>
             <param>const <type>VkBufferConstraintsInfoFUCHSIA</type>* <name>pBufferConstraintsInfo</name></param>
         </command>
         <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
+            <proto><type>VkResult</type> <name>vkSetBufferCollectionBufferConstraintsFUCHSIAX</name></proto>
+            <param><type>VkDevice</type> <name>device</name></param>
+            <param><type>VkBufferCollectionFUCHSIAX</type> <name>collection</name></param>
+            <param>const <type>VkBufferConstraintsInfoFUCHSIAX</type>* <name>pBufferConstraintsInfo</name></param>
+        </command>
+        <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
             <proto><type>VkResult</type> <name>vkSetBufferCollectionImageConstraintsFUCHSIA</name></proto>
             <param><type>VkDevice</type> <name>device</name></param>
             <param><type>VkBufferCollectionFUCHSIA</type> <name>collection</name></param>
             <param>const <type>VkImageConstraintsInfoFUCHSIA</type>* <name>pImageConstraintsInfo</name></param>
         </command>
+        <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
+            <proto><type>VkResult</type> <name>vkSetBufferCollectionImageConstraintsFUCHSIAX</name></proto>
+            <param><type>VkDevice</type> <name>device</name></param>
+            <param><type>VkBufferCollectionFUCHSIAX</type> <name>collection</name></param>
+            <param>const <type>VkImageConstraintsInfoFUCHSIAX</type>* <name>pImageConstraintsInfo</name></param>
+        </command>
         <command>
             <proto><type>void</type> <name>vkDestroyBufferCollectionFUCHSIA</name></proto>
             <param><type>VkDevice</type> <name>device</name></param>
             <param><type>VkBufferCollectionFUCHSIA</type> <name>collection</name></param>
             <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
         </command>
+        <command>
+            <proto><type>void</type> <name>vkDestroyBufferCollectionFUCHSIAX</name></proto>
+            <param><type>VkDevice</type> <name>device</name></param>
+            <param><type>VkBufferCollectionFUCHSIAX</type> <name>collection</name></param>
+            <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
+        </command>
         <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
             <proto><type>VkResult</type> <name>vkGetBufferCollectionPropertiesFUCHSIA</name></proto>
             <param><type>VkDevice</type> <name>device</name></param>
@@ -8130,11 +8252,23 @@
             <param><type>VkBufferCollectionPropertiesFUCHSIA</type>* <name>pProperties</name></param>
         </command>
         <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
+            <proto><type>VkResult</type> <name>vkGetBufferCollectionPropertiesFUCHSIAX</name></proto>
+            <param><type>VkDevice</type> <name>device</name></param>
+            <param><type>VkBufferCollectionFUCHSIAX</type> <name>collection</name></param>
+            <param><type>VkBufferCollectionPropertiesFUCHSIAX</type>* <name>pProperties</name></param>
+        </command>
+        <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
             <proto><type>VkResult</type> <name>vkGetBufferCollectionProperties2FUCHSIA</name></proto>
             <param><type>VkDevice</type> <name>device</name></param>
             <param><type>VkBufferCollectionFUCHSIA</type> <name>collection</name></param>
             <param><type>VkBufferCollectionProperties2FUCHSIA</type>* <name>pProperties</name></param>
         </command>
+        <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
+            <proto><type>VkResult</type> <name>vkGetBufferCollectionProperties2FUCHSIAX</name></proto>
+            <param><type>VkDevice</type> <name>device</name></param>
+            <param><type>VkBufferCollectionFUCHSIAX</type> <name>collection</name></param>
+            <param><type>VkBufferCollectionProperties2FUCHSIAX</type>* <name>pProperties</name></param>
+        </command>
         <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY">
             <proto><type>VkResult</type> <name>vkTrimCompactImageDeviceMemoryFUCHSIA</name></proto>
             <param><type>VkDevice</type> <name>device</name></param>
@@ -9900,7 +10034,6 @@
             <type name="VkQueueFlags"/>
             <type name="VkSampleCountFlagBits"/>
             <type name="VkSampleCountFlags"/>
-            <type name="VkStructureType"/>
             <type name="VkSystemAllocationScope"/>
             <command name="vkCreateInstance"/>
             <command name="vkDestroyInstance"/>
@@ -15206,10 +15339,44 @@
                 <enum value="&quot;VK_EXT_extension_367&quot;"              name="VK_EXT_EXTENSION_367_EXTENSION_NAME"/>
             </require>
         </extension>
-        <extension name="VK_FUCHSIA_extension_368" number="368" author="FUCHSIA" contact="Craig Stout @cdotstout" supported="disabled">
+        <extension name="VK_FUCHSIA_buffer_collection_x" number="368" type="device" requires="VK_FUCHSIA_external_memory,VK_KHR_sampler_ycbcr_conversion" author="FUCHSIA" contact="John Bauman @jbauman" supported="vulkan" platform="fuchsia">
             <require>
-                <enum value="0"                                             name="VK_EXT_EXTENSION_368_SPEC_VERSION"/>
-                <enum value="&quot;VK_EXT_extension_368&quot;"              name="VK_EXT_EXTENSION_368_EXTENSION_NAME"/>
+                <enum value="1"                                         name="VK_FUCHSIA_BUFFER_COLLECTION_X_SPEC_VERSION"/>
+                <enum value="&quot;VK_FUCHSIA_buffer_collection_x&quot;"  name="VK_FUCHSIA_BUFFER_COLLECTION_X_EXTENSION_NAME"/>
+                <enum offset="0" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIAX"/>
+                <enum offset="2" extends="VkObjectType"                 name="VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIAX" comment="VkBufferCollectionFUCHSIAX"/>
+                <enum offset="3" extends="VkDebugReportObjectTypeEXT"   name="VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIAX_EXT"/>
+                <enum offset="4" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIAX"/>
+                <enum offset="5" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIAX"/>
+                <enum offset="6" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIAX"/>
+                <enum offset="7" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIAX"/>
+                <enum offset="8" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIAX"/>
+                <enum offset="9" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIAX"/>
+                <enum offset="10" extends="VkStructureType"             name="VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIAX"/>
+                <enum offset="11" extends="VkStructureType"             name="VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES2_FUCHSIAX"/>
+                <enum offset="12" extends="VkStructureType"             name="VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIAX"/>
+                <type name="VkBufferCollectionFUCHSIAX"/>
+                <type name="VkBufferCollectionCreateInfoFUCHSIAX"/>
+                <type name="VkImportMemoryBufferCollectionFUCHSIAX"/>
+                <type name="VkBufferCollectionImageCreateInfoFUCHSIAX"/>
+                <type name="VkBufferConstraintsInfoFUCHSIAX"/>
+                <type name="VkBufferCollectionBufferCreateInfoFUCHSIAX"/>
+                <type name="VkBufferCollectionPropertiesFUCHSIAX"/>
+                <type name="VkBufferCollectionProperties2FUCHSIAX"/>
+                <type name="VkImageFormatConstraintsFlagBitsFUCHSIAX"/>
+                <type name="VkImageFormatConstraintsFlagsFUCHSIAX"/>
+                <type name="VkSysmemColorSpaceFUCHSIAX"/>
+                <type name="VkImageConstraintsInfoFlagBitsFUCHSIAX"/>
+                <type name="VkImageConstraintsInfoFlagsFUCHSIAX"/>
+                <type name="VkImageConstraintsInfoFUCHSIAX"/>
+                <type name="VkImageFormatConstraintsInfoFUCHSIAX"/>
+                <command name="vkCreateBufferCollectionFUCHSIAX"/>
+                <command name="vkSetBufferCollectionConstraintsFUCHSIAX"/>
+                <command name="vkSetBufferCollectionImageConstraintsFUCHSIAX"/>
+                <command name="vkSetBufferCollectionBufferConstraintsFUCHSIAX"/>
+                <command name="vkDestroyBufferCollectionFUCHSIAX"/>
+                <command name="vkGetBufferCollectionPropertiesFUCHSIAX"/>
+                <command name="vkGetBufferCollectionProperties2FUCHSIAX"/>
             </require>
         </extension>
         <extension name="VK_QCOM_extension_369" number="369" author="QCOM" contact="Matthew Netsch @mnetsch" supported="disabled">
diff --git a/scripts/rebuild.sh b/scripts/rebuild.sh
index 6532716..952c68d 100755
--- a/scripts/rebuild.sh
+++ b/scripts/rebuild.sh
@@ -7,6 +7,7 @@
 
 script_path="$( cd "$(dirname "$0")" >/dev/null 2>&1 ; pwd -P )"
 headers_path=$script_path/..
+
 if [[ $# -lt 2 ]]
 then
   echo "Usage: rebuild.sh <Vulkan-Docs path> <Vulkan-Hpp path>"
@@ -23,5 +24,11 @@
 
 cd $vullkan_hpp_path
 ./VulkanHppGenerator $headers_path/registry/vk.xml
-$headers_path/../../prebuilt/third_party/clang/linux-x64/bin/clang-format --style=file -i vulkan/vulkan.hpp
+
+case "$OSTYPE" in
+  darwin*)  arch="mac-x64" ;;
+  linux*)   arch="linux-x64" ;;
+  *)        echo "Unknown: $OSTYPE"; exit ;;
+esac
+$headers_path/../../prebuilt/third_party/clang/${arch}/bin/clang-format --style=file -i vulkan/vulkan.hpp
 cp -v vulkan/vulkan.hpp $headers_path/include/vulkan