system/vulkan_enc/goldfish_vk_handlemap_guest.h - device/generic/goldfish-opengl - Git at Google

 // Copyright (C) 2018 The Android Open Source Project
 // Copyright (C) 2018 Google Inc.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 // http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 // Autogenerated module goldfish_vk_handlemap_guest
 //
 // (header) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml
 // cereal -o ../vulkan-cereal/stream-servers/vulkan/cereal
 //
 // Please do not modify directly;
 // re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
 // or directly from Python by defining:
 // VULKAN_REGISTRY_XML_DIR : Directory containing vk.xml
 // VULKAN_REGISTRY_SCRIPTS_DIR : Directory containing genvk.py
 // CEREAL_OUTPUT_DIR: Where to put the generated sources.
 //
 // python3 $VULKAN_REGISTRY_SCRIPTS_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o
 // $CEREAL_OUTPUT_DIR
 //
 #pragma once
 #include <vulkan/vulkan.h>

 #include "VulkanHandleMapping.h"
 #include "goldfish_vk_private_defs.h"
 #include "vk_platform_compat.h"
 #include "vulkan_gfxstream.h"
 // Stuff we are not going to use but if included,
 // will cause compile errors. These are Android Vulkan
 // required extensions, but the approach will be to
 // implement them completely on the guest side.
 #undef VK_KHR_android_surface
 #undef VK_ANDROID_external_memory_android_hardware_buffer

 namespace gfxstream {
 namespace vk {

 #ifdef VK_VERSION_1_0
 void handlemap_VkExtent2D(VulkanHandleMapping* handlemap, VkExtent2D* toMap);

 void handlemap_VkExtent3D(VulkanHandleMapping* handlemap, VkExtent3D* toMap);

 void handlemap_VkOffset2D(VulkanHandleMapping* handlemap, VkOffset2D* toMap);

 void handlemap_VkOffset3D(VulkanHandleMapping* handlemap, VkOffset3D* toMap);

 void handlemap_VkRect2D(VulkanHandleMapping* handlemap, VkRect2D* toMap);

 void handlemap_VkBaseInStructure(VulkanHandleMapping* handlemap, VkBaseInStructure* toMap);

 void handlemap_VkBaseOutStructure(VulkanHandleMapping* handlemap, VkBaseOutStructure* toMap);

 void handlemap_VkBufferMemoryBarrier(VulkanHandleMapping* handlemap, VkBufferMemoryBarrier* toMap);

 void handlemap_VkDispatchIndirectCommand(VulkanHandleMapping* handlemap,
                                          VkDispatchIndirectCommand* toMap);

 void handlemap_VkDrawIndexedIndirectCommand(VulkanHandleMapping* handlemap,
                                             VkDrawIndexedIndirectCommand* toMap);

 void handlemap_VkDrawIndirectCommand(VulkanHandleMapping* handlemap, VkDrawIndirectCommand* toMap);

 void handlemap_VkImageSubresourceRange(VulkanHandleMapping* handlemap,
                                        VkImageSubresourceRange* toMap);

 void handlemap_VkImageMemoryBarrier(VulkanHandleMapping* handlemap, VkImageMemoryBarrier* toMap);

 void handlemap_VkMemoryBarrier(VulkanHandleMapping* handlemap, VkMemoryBarrier* toMap);

 void handlemap_VkPipelineCacheHeaderVersionOne(VulkanHandleMapping* handlemap,
                                                VkPipelineCacheHeaderVersionOne* toMap);

 void handlemap_VkAllocationCallbacks(VulkanHandleMapping* handlemap, VkAllocationCallbacks* toMap);

 void handlemap_VkApplicationInfo(VulkanHandleMapping* handlemap, VkApplicationInfo* toMap);

 void handlemap_VkFormatProperties(VulkanHandleMapping* handlemap, VkFormatProperties* toMap);

 void handlemap_VkImageFormatProperties(VulkanHandleMapping* handlemap,
                                        VkImageFormatProperties* toMap);

 void handlemap_VkInstanceCreateInfo(VulkanHandleMapping* handlemap, VkInstanceCreateInfo* toMap);

 void handlemap_VkMemoryHeap(VulkanHandleMapping* handlemap, VkMemoryHeap* toMap);

 void handlemap_VkMemoryType(VulkanHandleMapping* handlemap, VkMemoryType* toMap);

 void handlemap_VkPhysicalDeviceFeatures(VulkanHandleMapping* handlemap,
                                         VkPhysicalDeviceFeatures* toMap);

 void handlemap_VkPhysicalDeviceLimits(VulkanHandleMapping* handlemap,
                                       VkPhysicalDeviceLimits* toMap);

 void handlemap_VkPhysicalDeviceMemoryProperties(VulkanHandleMapping* handlemap,
                                                 VkPhysicalDeviceMemoryProperties* toMap);

 void handlemap_VkPhysicalDeviceSparseProperties(VulkanHandleMapping* handlemap,
                                                 VkPhysicalDeviceSparseProperties* toMap);

 void handlemap_VkPhysicalDeviceProperties(VulkanHandleMapping* handlemap,
                                           VkPhysicalDeviceProperties* toMap);

 void handlemap_VkQueueFamilyProperties(VulkanHandleMapping* handlemap,
                                        VkQueueFamilyProperties* toMap);

 void handlemap_VkDeviceQueueCreateInfo(VulkanHandleMapping* handlemap,
                                        VkDeviceQueueCreateInfo* toMap);

 void handlemap_VkDeviceCreateInfo(VulkanHandleMapping* handlemap, VkDeviceCreateInfo* toMap);

 void handlemap_VkExtensionProperties(VulkanHandleMapping* handlemap, VkExtensionProperties* toMap);

 void handlemap_VkLayerProperties(VulkanHandleMapping* handlemap, VkLayerProperties* toMap);

 void handlemap_VkSubmitInfo(VulkanHandleMapping* handlemap, VkSubmitInfo* toMap);

 void handlemap_VkMappedMemoryRange(VulkanHandleMapping* handlemap, VkMappedMemoryRange* toMap);

 void handlemap_VkMemoryAllocateInfo(VulkanHandleMapping* handlemap, VkMemoryAllocateInfo* toMap);

 void handlemap_VkMemoryRequirements(VulkanHandleMapping* handlemap, VkMemoryRequirements* toMap);

 void handlemap_VkSparseMemoryBind(VulkanHandleMapping* handlemap, VkSparseMemoryBind* toMap);

 void handlemap_VkSparseBufferMemoryBindInfo(VulkanHandleMapping* handlemap,
                                             VkSparseBufferMemoryBindInfo* toMap);

 void handlemap_VkSparseImageOpaqueMemoryBindInfo(VulkanHandleMapping* handlemap,
                                                  VkSparseImageOpaqueMemoryBindInfo* toMap);

 void handlemap_VkImageSubresource(VulkanHandleMapping* handlemap, VkImageSubresource* toMap);

 void handlemap_VkSparseImageMemoryBind(VulkanHandleMapping* handlemap,
                                        VkSparseImageMemoryBind* toMap);

 void handlemap_VkSparseImageMemoryBindInfo(VulkanHandleMapping* handlemap,
                                            VkSparseImageMemoryBindInfo* toMap);

 void handlemap_VkBindSparseInfo(VulkanHandleMapping* handlemap, VkBindSparseInfo* toMap);

 void handlemap_VkSparseImageFormatProperties(VulkanHandleMapping* handlemap,
                                              VkSparseImageFormatProperties* toMap);

 void handlemap_VkSparseImageMemoryRequirements(VulkanHandleMapping* handlemap,
                                                VkSparseImageMemoryRequirements* toMap);

 void handlemap_VkFenceCreateInfo(VulkanHandleMapping* handlemap, VkFenceCreateInfo* toMap);

 void handlemap_VkSemaphoreCreateInfo(VulkanHandleMapping* handlemap, VkSemaphoreCreateInfo* toMap);

 void handlemap_VkEventCreateInfo(VulkanHandleMapping* handlemap, VkEventCreateInfo* toMap);

 void handlemap_VkQueryPoolCreateInfo(VulkanHandleMapping* handlemap, VkQueryPoolCreateInfo* toMap);

 void handlemap_VkBufferCreateInfo(VulkanHandleMapping* handlemap, VkBufferCreateInfo* toMap);

 void handlemap_VkBufferViewCreateInfo(VulkanHandleMapping* handlemap,
                                       VkBufferViewCreateInfo* toMap);

 void handlemap_VkImageCreateInfo(VulkanHandleMapping* handlemap, VkImageCreateInfo* toMap);

 void handlemap_VkSubresourceLayout(VulkanHandleMapping* handlemap, VkSubresourceLayout* toMap);

 void handlemap_VkComponentMapping(VulkanHandleMapping* handlemap, VkComponentMapping* toMap);

 void handlemap_VkImageViewCreateInfo(VulkanHandleMapping* handlemap, VkImageViewCreateInfo* toMap);

 void handlemap_VkShaderModuleCreateInfo(VulkanHandleMapping* handlemap,
                                         VkShaderModuleCreateInfo* toMap);

 void handlemap_VkPipelineCacheCreateInfo(VulkanHandleMapping* handlemap,
                                          VkPipelineCacheCreateInfo* toMap);

 void handlemap_VkSpecializationMapEntry(VulkanHandleMapping* handlemap,
                                         VkSpecializationMapEntry* toMap);

 void handlemap_VkSpecializationInfo(VulkanHandleMapping* handlemap, VkSpecializationInfo* toMap);

 void handlemap_VkPipelineShaderStageCreateInfo(VulkanHandleMapping* handlemap,
                                                VkPipelineShaderStageCreateInfo* toMap);

 void handlemap_VkComputePipelineCreateInfo(VulkanHandleMapping* handlemap,
                                            VkComputePipelineCreateInfo* toMap);

 void handlemap_VkVertexInputBindingDescription(VulkanHandleMapping* handlemap,
                                                VkVertexInputBindingDescription* toMap);

 void handlemap_VkVertexInputAttributeDescription(VulkanHandleMapping* handlemap,
                                                  VkVertexInputAttributeDescription* toMap);

 void handlemap_VkPipelineVertexInputStateCreateInfo(VulkanHandleMapping* handlemap,
                                                     VkPipelineVertexInputStateCreateInfo* toMap);

 void handlemap_VkPipelineInputAssemblyStateCreateInfo(
     VulkanHandleMapping* handlemap, VkPipelineInputAssemblyStateCreateInfo* toMap);

 void handlemap_VkPipelineTessellationStateCreateInfo(VulkanHandleMapping* handlemap,
                                                      VkPipelineTessellationStateCreateInfo* toMap);

 void handlemap_VkViewport(VulkanHandleMapping* handlemap, VkViewport* toMap);

 void handlemap_VkPipelineViewportStateCreateInfo(VulkanHandleMapping* handlemap,
                                                  VkPipelineViewportStateCreateInfo* toMap);

 void handlemap_VkPipelineRasterizationStateCreateInfo(
     VulkanHandleMapping* handlemap, VkPipelineRasterizationStateCreateInfo* toMap);

 void handlemap_VkPipelineMultisampleStateCreateInfo(VulkanHandleMapping* handlemap,
                                                     VkPipelineMultisampleStateCreateInfo* toMap);

 void handlemap_VkStencilOpState(VulkanHandleMapping* handlemap, VkStencilOpState* toMap);

 void handlemap_VkPipelineDepthStencilStateCreateInfo(VulkanHandleMapping* handlemap,
                                                      VkPipelineDepthStencilStateCreateInfo* toMap);

 void handlemap_VkPipelineColorBlendAttachmentState(VulkanHandleMapping* handlemap,
                                                    VkPipelineColorBlendAttachmentState* toMap);

 void handlemap_VkPipelineColorBlendStateCreateInfo(VulkanHandleMapping* handlemap,
                                                    VkPipelineColorBlendStateCreateInfo* toMap);

 void handlemap_VkPipelineDynamicStateCreateInfo(VulkanHandleMapping* handlemap,
                                                 VkPipelineDynamicStateCreateInfo* toMap);

 void handlemap_VkGraphicsPipelineCreateInfo(VulkanHandleMapping* handlemap,
                                             VkGraphicsPipelineCreateInfo* toMap);

 void handlemap_VkPushConstantRange(VulkanHandleMapping* handlemap, VkPushConstantRange* toMap);

 void handlemap_VkPipelineLayoutCreateInfo(VulkanHandleMapping* handlemap,
                                           VkPipelineLayoutCreateInfo* toMap);

 void handlemap_VkSamplerCreateInfo(VulkanHandleMapping* handlemap, VkSamplerCreateInfo* toMap);

 void handlemap_VkCopyDescriptorSet(VulkanHandleMapping* handlemap, VkCopyDescriptorSet* toMap);

 void handlemap_VkDescriptorBufferInfo(VulkanHandleMapping* handlemap,
                                       VkDescriptorBufferInfo* toMap);

 void handlemap_VkDescriptorImageInfo(VulkanHandleMapping* handlemap, VkDescriptorImageInfo* toMap);

 void handlemap_VkDescriptorPoolSize(VulkanHandleMapping* handlemap, VkDescriptorPoolSize* toMap);

 void handlemap_VkDescriptorPoolCreateInfo(VulkanHandleMapping* handlemap,
                                           VkDescriptorPoolCreateInfo* toMap);

 void handlemap_VkDescriptorSetAllocateInfo(VulkanHandleMapping* handlemap,
                                            VkDescriptorSetAllocateInfo* toMap);

 void handlemap_VkDescriptorSetLayoutBinding(VulkanHandleMapping* handlemap,
                                             VkDescriptorSetLayoutBinding* toMap);

 void handlemap_VkDescriptorSetLayoutCreateInfo(VulkanHandleMapping* handlemap,
                                                VkDescriptorSetLayoutCreateInfo* toMap);

 void handlemap_VkWriteDescriptorSet(VulkanHandleMapping* handlemap, VkWriteDescriptorSet* toMap);

 void handlemap_VkAttachmentDescription(VulkanHandleMapping* handlemap,
                                        VkAttachmentDescription* toMap);

 void handlemap_VkAttachmentReference(VulkanHandleMapping* handlemap, VkAttachmentReference* toMap);

 void handlemap_VkFramebufferCreateInfo(VulkanHandleMapping* handlemap,
                                        VkFramebufferCreateInfo* toMap);

 void handlemap_VkSubpassDescription(VulkanHandleMapping* handlemap, VkSubpassDescription* toMap);

 void handlemap_VkSubpassDependency(VulkanHandleMapping* handlemap, VkSubpassDependency* toMap);

 void handlemap_VkRenderPassCreateInfo(VulkanHandleMapping* handlemap,
                                       VkRenderPassCreateInfo* toMap);

 void handlemap_VkCommandPoolCreateInfo(VulkanHandleMapping* handlemap,
                                        VkCommandPoolCreateInfo* toMap);

 void handlemap_VkCommandBufferAllocateInfo(VulkanHandleMapping* handlemap,
                                            VkCommandBufferAllocateInfo* toMap);

 void handlemap_VkCommandBufferInheritanceInfo(VulkanHandleMapping* handlemap,
                                               VkCommandBufferInheritanceInfo* toMap);

 void handlemap_VkCommandBufferBeginInfo(VulkanHandleMapping* handlemap,
                                         VkCommandBufferBeginInfo* toMap);

 void handlemap_VkBufferCopy(VulkanHandleMapping* handlemap, VkBufferCopy* toMap);

 void handlemap_VkImageSubresourceLayers(VulkanHandleMapping* handlemap,
                                         VkImageSubresourceLayers* toMap);

 void handlemap_VkBufferImageCopy(VulkanHandleMapping* handlemap, VkBufferImageCopy* toMap);

 void handlemap_VkClearColorValue(VulkanHandleMapping* handlemap, VkClearColorValue* toMap);

 void handlemap_VkClearDepthStencilValue(VulkanHandleMapping* handlemap,
                                         VkClearDepthStencilValue* toMap);

 void handlemap_VkClearValue(VulkanHandleMapping* handlemap, VkClearValue* toMap);

 void handlemap_VkClearAttachment(VulkanHandleMapping* handlemap, VkClearAttachment* toMap);

 void handlemap_VkClearRect(VulkanHandleMapping* handlemap, VkClearRect* toMap);

 void handlemap_VkImageBlit(VulkanHandleMapping* handlemap, VkImageBlit* toMap);

 void handlemap_VkImageCopy(VulkanHandleMapping* handlemap, VkImageCopy* toMap);

 void handlemap_VkImageResolve(VulkanHandleMapping* handlemap, VkImageResolve* toMap);

 void handlemap_VkRenderPassBeginInfo(VulkanHandleMapping* handlemap, VkRenderPassBeginInfo* toMap);

 #endif
 #ifdef VK_VERSION_1_1
 void handlemap_VkPhysicalDeviceSubgroupProperties(VulkanHandleMapping* handlemap,
                                                   VkPhysicalDeviceSubgroupProperties* toMap);

 void handlemap_VkBindBufferMemoryInfo(VulkanHandleMapping* handlemap,
                                       VkBindBufferMemoryInfo* toMap);

 void handlemap_VkBindImageMemoryInfo(VulkanHandleMapping* handlemap, VkBindImageMemoryInfo* toMap);

 void handlemap_VkPhysicalDevice16BitStorageFeatures(VulkanHandleMapping* handlemap,
                                                     VkPhysicalDevice16BitStorageFeatures* toMap);

 void handlemap_VkMemoryDedicatedRequirements(VulkanHandleMapping* handlemap,
                                              VkMemoryDedicatedRequirements* toMap);

 void handlemap_VkMemoryDedicatedAllocateInfo(VulkanHandleMapping* handlemap,
                                              VkMemoryDedicatedAllocateInfo* toMap);

 void handlemap_VkMemoryAllocateFlagsInfo(VulkanHandleMapping* handlemap,
                                          VkMemoryAllocateFlagsInfo* toMap);

 void handlemap_VkDeviceGroupRenderPassBeginInfo(VulkanHandleMapping* handlemap,
                                                 VkDeviceGroupRenderPassBeginInfo* toMap);

 void handlemap_VkDeviceGroupCommandBufferBeginInfo(VulkanHandleMapping* handlemap,
                                                    VkDeviceGroupCommandBufferBeginInfo* toMap);

 void handlemap_VkDeviceGroupSubmitInfo(VulkanHandleMapping* handlemap,
                                        VkDeviceGroupSubmitInfo* toMap);

 void handlemap_VkDeviceGroupBindSparseInfo(VulkanHandleMapping* handlemap,
                                            VkDeviceGroupBindSparseInfo* toMap);

 void handlemap_VkBindBufferMemoryDeviceGroupInfo(VulkanHandleMapping* handlemap,
                                                  VkBindBufferMemoryDeviceGroupInfo* toMap);

 void handlemap_VkBindImageMemoryDeviceGroupInfo(VulkanHandleMapping* handlemap,
                                                 VkBindImageMemoryDeviceGroupInfo* toMap);

 void handlemap_VkPhysicalDeviceGroupProperties(VulkanHandleMapping* handlemap,
                                                VkPhysicalDeviceGroupProperties* toMap);

 void handlemap_VkDeviceGroupDeviceCreateInfo(VulkanHandleMapping* handlemap,
                                              VkDeviceGroupDeviceCreateInfo* toMap);

 void handlemap_VkBufferMemoryRequirementsInfo2(VulkanHandleMapping* handlemap,
                                                VkBufferMemoryRequirementsInfo2* toMap);

 void handlemap_VkImageMemoryRequirementsInfo2(VulkanHandleMapping* handlemap,
                                               VkImageMemoryRequirementsInfo2* toMap);

 void handlemap_VkImageSparseMemoryRequirementsInfo2(VulkanHandleMapping* handlemap,
                                                     VkImageSparseMemoryRequirementsInfo2* toMap);

 void handlemap_VkMemoryRequirements2(VulkanHandleMapping* handlemap, VkMemoryRequirements2* toMap);

 void handlemap_VkSparseImageMemoryRequirements2(VulkanHandleMapping* handlemap,
                                                 VkSparseImageMemoryRequirements2* toMap);

 void handlemap_VkPhysicalDeviceFeatures2(VulkanHandleMapping* handlemap,
                                          VkPhysicalDeviceFeatures2* toMap);

 void handlemap_VkPhysicalDeviceProperties2(VulkanHandleMapping* handlemap,
                                            VkPhysicalDeviceProperties2* toMap);

 void handlemap_VkFormatProperties2(VulkanHandleMapping* handlemap, VkFormatProperties2* toMap);

 void handlemap_VkImageFormatProperties2(VulkanHandleMapping* handlemap,
                                         VkImageFormatProperties2* toMap);

 void handlemap_VkPhysicalDeviceImageFormatInfo2(VulkanHandleMapping* handlemap,
                                                 VkPhysicalDeviceImageFormatInfo2* toMap);

 void handlemap_VkQueueFamilyProperties2(VulkanHandleMapping* handlemap,
                                         VkQueueFamilyProperties2* toMap);

 void handlemap_VkPhysicalDeviceMemoryProperties2(VulkanHandleMapping* handlemap,
                                                  VkPhysicalDeviceMemoryProperties2* toMap);

 void handlemap_VkSparseImageFormatProperties2(VulkanHandleMapping* handlemap,
                                               VkSparseImageFormatProperties2* toMap);

 void handlemap_VkPhysicalDeviceSparseImageFormatInfo2(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceSparseImageFormatInfo2* toMap);

 void handlemap_VkPhysicalDevicePointClippingProperties(
     VulkanHandleMapping* handlemap, VkPhysicalDevicePointClippingProperties* toMap);

 void handlemap_VkInputAttachmentAspectReference(VulkanHandleMapping* handlemap,
                                                 VkInputAttachmentAspectReference* toMap);

 void handlemap_VkRenderPassInputAttachmentAspectCreateInfo(
     VulkanHandleMapping* handlemap, VkRenderPassInputAttachmentAspectCreateInfo* toMap);

 void handlemap_VkImageViewUsageCreateInfo(VulkanHandleMapping* handlemap,
                                           VkImageViewUsageCreateInfo* toMap);

 void handlemap_VkPipelineTessellationDomainOriginStateCreateInfo(
     VulkanHandleMapping* handlemap, VkPipelineTessellationDomainOriginStateCreateInfo* toMap);

 void handlemap_VkRenderPassMultiviewCreateInfo(VulkanHandleMapping* handlemap,
                                                VkRenderPassMultiviewCreateInfo* toMap);

 void handlemap_VkPhysicalDeviceMultiviewFeatures(VulkanHandleMapping* handlemap,
                                                  VkPhysicalDeviceMultiviewFeatures* toMap);

 void handlemap_VkPhysicalDeviceMultiviewProperties(VulkanHandleMapping* handlemap,
                                                    VkPhysicalDeviceMultiviewProperties* toMap);

 void handlemap_VkPhysicalDeviceVariablePointersFeatures(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceVariablePointersFeatures* toMap);

 DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceVariablePointersFeatures,
                       handlemap_VkPhysicalDeviceVariablePointerFeatures)

 void handlemap_VkPhysicalDeviceProtectedMemoryFeatures(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceProtectedMemoryFeatures* toMap);

 void handlemap_VkPhysicalDeviceProtectedMemoryProperties(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceProtectedMemoryProperties* toMap);

 void handlemap_VkDeviceQueueInfo2(VulkanHandleMapping* handlemap, VkDeviceQueueInfo2* toMap);

 void handlemap_VkProtectedSubmitInfo(VulkanHandleMapping* handlemap, VkProtectedSubmitInfo* toMap);

 void handlemap_VkSamplerYcbcrConversionCreateInfo(VulkanHandleMapping* handlemap,
                                                   VkSamplerYcbcrConversionCreateInfo* toMap);

 void handlemap_VkSamplerYcbcrConversionInfo(VulkanHandleMapping* handlemap,
                                             VkSamplerYcbcrConversionInfo* toMap);

 void handlemap_VkBindImagePlaneMemoryInfo(VulkanHandleMapping* handlemap,
                                           VkBindImagePlaneMemoryInfo* toMap);

 void handlemap_VkImagePlaneMemoryRequirementsInfo(VulkanHandleMapping* handlemap,
                                                   VkImagePlaneMemoryRequirementsInfo* toMap);

 void handlemap_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceSamplerYcbcrConversionFeatures* toMap);

 void handlemap_VkSamplerYcbcrConversionImageFormatProperties(
     VulkanHandleMapping* handlemap, VkSamplerYcbcrConversionImageFormatProperties* toMap);

 void handlemap_VkDescriptorUpdateTemplateEntry(VulkanHandleMapping* handlemap,
                                                VkDescriptorUpdateTemplateEntry* toMap);

 void handlemap_VkDescriptorUpdateTemplateCreateInfo(VulkanHandleMapping* handlemap,
                                                     VkDescriptorUpdateTemplateCreateInfo* toMap);

 void handlemap_VkExternalMemoryProperties(VulkanHandleMapping* handlemap,
                                           VkExternalMemoryProperties* toMap);

 void handlemap_VkPhysicalDeviceExternalImageFormatInfo(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceExternalImageFormatInfo* toMap);

 void handlemap_VkExternalImageFormatProperties(VulkanHandleMapping* handlemap,
                                                VkExternalImageFormatProperties* toMap);

 void handlemap_VkPhysicalDeviceExternalBufferInfo(VulkanHandleMapping* handlemap,
                                                   VkPhysicalDeviceExternalBufferInfo* toMap);

 void handlemap_VkExternalBufferProperties(VulkanHandleMapping* handlemap,
                                           VkExternalBufferProperties* toMap);

 void handlemap_VkPhysicalDeviceIDProperties(VulkanHandleMapping* handlemap,
                                             VkPhysicalDeviceIDProperties* toMap);

 void handlemap_VkExternalMemoryImageCreateInfo(VulkanHandleMapping* handlemap,
                                                VkExternalMemoryImageCreateInfo* toMap);

 void handlemap_VkExternalMemoryBufferCreateInfo(VulkanHandleMapping* handlemap,
                                                 VkExternalMemoryBufferCreateInfo* toMap);

 void handlemap_VkExportMemoryAllocateInfo(VulkanHandleMapping* handlemap,
                                           VkExportMemoryAllocateInfo* toMap);

 void handlemap_VkPhysicalDeviceExternalFenceInfo(VulkanHandleMapping* handlemap,
                                                  VkPhysicalDeviceExternalFenceInfo* toMap);

 void handlemap_VkExternalFenceProperties(VulkanHandleMapping* handlemap,
                                          VkExternalFenceProperties* toMap);

 void handlemap_VkExportFenceCreateInfo(VulkanHandleMapping* handlemap,
                                        VkExportFenceCreateInfo* toMap);

 void handlemap_VkExportSemaphoreCreateInfo(VulkanHandleMapping* handlemap,
                                            VkExportSemaphoreCreateInfo* toMap);

 void handlemap_VkPhysicalDeviceExternalSemaphoreInfo(VulkanHandleMapping* handlemap,
                                                      VkPhysicalDeviceExternalSemaphoreInfo* toMap);

 void handlemap_VkExternalSemaphoreProperties(VulkanHandleMapping* handlemap,
                                              VkExternalSemaphoreProperties* toMap);

 void handlemap_VkPhysicalDeviceMaintenance3Properties(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceMaintenance3Properties* toMap);

 void handlemap_VkDescriptorSetLayoutSupport(VulkanHandleMapping* handlemap,
                                             VkDescriptorSetLayoutSupport* toMap);

 void handlemap_VkPhysicalDeviceShaderDrawParametersFeatures(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderDrawParametersFeatures* toMap);

 DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceShaderDrawParametersFeatures,
                       handlemap_VkPhysicalDeviceShaderDrawParameterFeatures)

 #endif
 #ifdef VK_VERSION_1_2
 void handlemap_VkPhysicalDeviceVulkan11Features(VulkanHandleMapping* handlemap,
                                                 VkPhysicalDeviceVulkan11Features* toMap);

 void handlemap_VkPhysicalDeviceVulkan11Properties(VulkanHandleMapping* handlemap,
                                                   VkPhysicalDeviceVulkan11Properties* toMap);

 void handlemap_VkPhysicalDeviceVulkan12Features(VulkanHandleMapping* handlemap,
                                                 VkPhysicalDeviceVulkan12Features* toMap);

 void handlemap_VkConformanceVersion(VulkanHandleMapping* handlemap, VkConformanceVersion* toMap);

 void handlemap_VkPhysicalDeviceVulkan12Properties(VulkanHandleMapping* handlemap,
                                                   VkPhysicalDeviceVulkan12Properties* toMap);

 void handlemap_VkImageFormatListCreateInfo(VulkanHandleMapping* handlemap,
                                            VkImageFormatListCreateInfo* toMap);

 void handlemap_VkAttachmentDescription2(VulkanHandleMapping* handlemap,
                                         VkAttachmentDescription2* toMap);

 void handlemap_VkAttachmentReference2(VulkanHandleMapping* handlemap,
                                       VkAttachmentReference2* toMap);

 void handlemap_VkSubpassDescription2(VulkanHandleMapping* handlemap, VkSubpassDescription2* toMap);

 void handlemap_VkSubpassDependency2(VulkanHandleMapping* handlemap, VkSubpassDependency2* toMap);

 void handlemap_VkRenderPassCreateInfo2(VulkanHandleMapping* handlemap,
                                        VkRenderPassCreateInfo2* toMap);

 void handlemap_VkSubpassBeginInfo(VulkanHandleMapping* handlemap, VkSubpassBeginInfo* toMap);

 void handlemap_VkSubpassEndInfo(VulkanHandleMapping* handlemap, VkSubpassEndInfo* toMap);

 void handlemap_VkPhysicalDevice8BitStorageFeatures(VulkanHandleMapping* handlemap,
                                                    VkPhysicalDevice8BitStorageFeatures* toMap);

 void handlemap_VkPhysicalDeviceDriverProperties(VulkanHandleMapping* handlemap,
                                                 VkPhysicalDeviceDriverProperties* toMap);

 void handlemap_VkPhysicalDeviceShaderAtomicInt64Features(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderAtomicInt64Features* toMap);

 void handlemap_VkPhysicalDeviceShaderFloat16Int8Features(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderFloat16Int8Features* toMap);

 void handlemap_VkPhysicalDeviceFloatControlsProperties(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceFloatControlsProperties* toMap);

 void handlemap_VkDescriptorSetLayoutBindingFlagsCreateInfo(
     VulkanHandleMapping* handlemap, VkDescriptorSetLayoutBindingFlagsCreateInfo* toMap);

 void handlemap_VkPhysicalDeviceDescriptorIndexingFeatures(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceDescriptorIndexingFeatures* toMap);

 void handlemap_VkPhysicalDeviceDescriptorIndexingProperties(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceDescriptorIndexingProperties* toMap);

 void handlemap_VkDescriptorSetVariableDescriptorCountAllocateInfo(
     VulkanHandleMapping* handlemap, VkDescriptorSetVariableDescriptorCountAllocateInfo* toMap);

 void handlemap_VkDescriptorSetVariableDescriptorCountLayoutSupport(
     VulkanHandleMapping* handlemap, VkDescriptorSetVariableDescriptorCountLayoutSupport* toMap);

 void handlemap_VkSubpassDescriptionDepthStencilResolve(
     VulkanHandleMapping* handlemap, VkSubpassDescriptionDepthStencilResolve* toMap);

 void handlemap_VkPhysicalDeviceDepthStencilResolveProperties(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceDepthStencilResolveProperties* toMap);

 void handlemap_VkPhysicalDeviceScalarBlockLayoutFeatures(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceScalarBlockLayoutFeatures* toMap);

 void handlemap_VkImageStencilUsageCreateInfo(VulkanHandleMapping* handlemap,
                                              VkImageStencilUsageCreateInfo* toMap);

 void handlemap_VkSamplerReductionModeCreateInfo(VulkanHandleMapping* handlemap,
                                                 VkSamplerReductionModeCreateInfo* toMap);

 void handlemap_VkPhysicalDeviceSamplerFilterMinmaxProperties(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceSamplerFilterMinmaxProperties* toMap);

 void handlemap_VkPhysicalDeviceVulkanMemoryModelFeatures(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceVulkanMemoryModelFeatures* toMap);

 void handlemap_VkPhysicalDeviceImagelessFramebufferFeatures(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceImagelessFramebufferFeatures* toMap);

 void handlemap_VkFramebufferAttachmentImageInfo(VulkanHandleMapping* handlemap,
                                                 VkFramebufferAttachmentImageInfo* toMap);

 void handlemap_VkFramebufferAttachmentsCreateInfo(VulkanHandleMapping* handlemap,
                                                   VkFramebufferAttachmentsCreateInfo* toMap);

 void handlemap_VkRenderPassAttachmentBeginInfo(VulkanHandleMapping* handlemap,
                                                VkRenderPassAttachmentBeginInfo* toMap);

 void handlemap_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceUniformBufferStandardLayoutFeatures* toMap);

 void handlemap_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* toMap);

 void handlemap_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* toMap);

 void handlemap_VkAttachmentReferenceStencilLayout(VulkanHandleMapping* handlemap,
                                                   VkAttachmentReferenceStencilLayout* toMap);

 void handlemap_VkAttachmentDescriptionStencilLayout(VulkanHandleMapping* handlemap,
                                                     VkAttachmentDescriptionStencilLayout* toMap);

 void handlemap_VkPhysicalDeviceHostQueryResetFeatures(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceHostQueryResetFeatures* toMap);

 void handlemap_VkPhysicalDeviceTimelineSemaphoreFeatures(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceTimelineSemaphoreFeatures* toMap);

 void handlemap_VkPhysicalDeviceTimelineSemaphoreProperties(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceTimelineSemaphoreProperties* toMap);

 void handlemap_VkSemaphoreTypeCreateInfo(VulkanHandleMapping* handlemap,
                                          VkSemaphoreTypeCreateInfo* toMap);

 void handlemap_VkTimelineSemaphoreSubmitInfo(VulkanHandleMapping* handlemap,
                                              VkTimelineSemaphoreSubmitInfo* toMap);

 void handlemap_VkSemaphoreWaitInfo(VulkanHandleMapping* handlemap, VkSemaphoreWaitInfo* toMap);

 void handlemap_VkSemaphoreSignalInfo(VulkanHandleMapping* handlemap, VkSemaphoreSignalInfo* toMap);

 void handlemap_VkPhysicalDeviceBufferDeviceAddressFeatures(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceBufferDeviceAddressFeatures* toMap);

 void handlemap_VkBufferDeviceAddressInfo(VulkanHandleMapping* handlemap,
                                          VkBufferDeviceAddressInfo* toMap);

 void handlemap_VkBufferOpaqueCaptureAddressCreateInfo(
     VulkanHandleMapping* handlemap, VkBufferOpaqueCaptureAddressCreateInfo* toMap);

 void handlemap_VkMemoryOpaqueCaptureAddressAllocateInfo(
     VulkanHandleMapping* handlemap, VkMemoryOpaqueCaptureAddressAllocateInfo* toMap);

 void handlemap_VkDeviceMemoryOpaqueCaptureAddressInfo(
     VulkanHandleMapping* handlemap, VkDeviceMemoryOpaqueCaptureAddressInfo* toMap);

 #endif
 #ifdef VK_KHR_surface
 void handlemap_VkSurfaceCapabilitiesKHR(VulkanHandleMapping* handlemap,
                                         VkSurfaceCapabilitiesKHR* toMap);

 void handlemap_VkSurfaceFormatKHR(VulkanHandleMapping* handlemap, VkSurfaceFormatKHR* toMap);

 #endif
 #ifdef VK_KHR_swapchain
 void handlemap_VkSwapchainCreateInfoKHR(VulkanHandleMapping* handlemap,
                                         VkSwapchainCreateInfoKHR* toMap);

 void handlemap_VkPresentInfoKHR(VulkanHandleMapping* handlemap, VkPresentInfoKHR* toMap);

 void handlemap_VkImageSwapchainCreateInfoKHR(VulkanHandleMapping* handlemap,
                                              VkImageSwapchainCreateInfoKHR* toMap);

 void handlemap_VkBindImageMemorySwapchainInfoKHR(VulkanHandleMapping* handlemap,
                                                  VkBindImageMemorySwapchainInfoKHR* toMap);

 void handlemap_VkAcquireNextImageInfoKHR(VulkanHandleMapping* handlemap,
                                          VkAcquireNextImageInfoKHR* toMap);

 void handlemap_VkDeviceGroupPresentCapabilitiesKHR(VulkanHandleMapping* handlemap,
                                                    VkDeviceGroupPresentCapabilitiesKHR* toMap);

 void handlemap_VkDeviceGroupPresentInfoKHR(VulkanHandleMapping* handlemap,
                                            VkDeviceGroupPresentInfoKHR* toMap);

 void handlemap_VkDeviceGroupSwapchainCreateInfoKHR(VulkanHandleMapping* handlemap,
                                                    VkDeviceGroupSwapchainCreateInfoKHR* toMap);

 #endif
 #ifdef VK_KHR_display
 void handlemap_VkDisplayModeParametersKHR(VulkanHandleMapping* handlemap,
                                           VkDisplayModeParametersKHR* toMap);

 void handlemap_VkDisplayModeCreateInfoKHR(VulkanHandleMapping* handlemap,
                                           VkDisplayModeCreateInfoKHR* toMap);

 void handlemap_VkDisplayModePropertiesKHR(VulkanHandleMapping* handlemap,
                                           VkDisplayModePropertiesKHR* toMap);

 void handlemap_VkDisplayPlaneCapabilitiesKHR(VulkanHandleMapping* handlemap,
                                              VkDisplayPlaneCapabilitiesKHR* toMap);

 void handlemap_VkDisplayPlanePropertiesKHR(VulkanHandleMapping* handlemap,
                                            VkDisplayPlanePropertiesKHR* toMap);

 void handlemap_VkDisplayPropertiesKHR(VulkanHandleMapping* handlemap,
                                       VkDisplayPropertiesKHR* toMap);

 void handlemap_VkDisplaySurfaceCreateInfoKHR(VulkanHandleMapping* handlemap,
                                              VkDisplaySurfaceCreateInfoKHR* toMap);

 #endif
 #ifdef VK_KHR_display_swapchain
 void handlemap_VkDisplayPresentInfoKHR(VulkanHandleMapping* handlemap,
                                        VkDisplayPresentInfoKHR* toMap);

 #endif
 #ifdef VK_KHR_xlib_surface
 void handlemap_VkXlibSurfaceCreateInfoKHR(VulkanHandleMapping* handlemap,
                                           VkXlibSurfaceCreateInfoKHR* toMap);

 #endif
 #ifdef VK_KHR_xcb_surface
 void handlemap_VkXcbSurfaceCreateInfoKHR(VulkanHandleMapping* handlemap,
                                          VkXcbSurfaceCreateInfoKHR* toMap);

 #endif
 #ifdef VK_KHR_wayland_surface
 void handlemap_VkWaylandSurfaceCreateInfoKHR(VulkanHandleMapping* handlemap,
                                              VkWaylandSurfaceCreateInfoKHR* toMap);

 #endif
 #ifdef VK_KHR_android_surface
 void handlemap_VkAndroidSurfaceCreateInfoKHR(VulkanHandleMapping* handlemap,
                                              VkAndroidSurfaceCreateInfoKHR* toMap);

 #endif
 #ifdef VK_KHR_win32_surface
 void handlemap_VkWin32SurfaceCreateInfoKHR(VulkanHandleMapping* handlemap,
                                            VkWin32SurfaceCreateInfoKHR* toMap);

 #endif
 #ifdef VK_KHR_sampler_mirror_clamp_to_edge
 #endif
 #ifdef VK_KHR_video_queue
 void handlemap_VkVideoQueueFamilyProperties2KHR(VulkanHandleMapping* handlemap,
                                                 VkVideoQueueFamilyProperties2KHR* toMap);

 void handlemap_VkVideoProfileKHR(VulkanHandleMapping* handlemap, VkVideoProfileKHR* toMap);

 void handlemap_VkVideoProfilesKHR(VulkanHandleMapping* handlemap, VkVideoProfilesKHR* toMap);

 void handlemap_VkVideoCapabilitiesKHR(VulkanHandleMapping* handlemap,
                                       VkVideoCapabilitiesKHR* toMap);

 void handlemap_VkPhysicalDeviceVideoFormatInfoKHR(VulkanHandleMapping* handlemap,
                                                   VkPhysicalDeviceVideoFormatInfoKHR* toMap);

 void handlemap_VkVideoFormatPropertiesKHR(VulkanHandleMapping* handlemap,
                                           VkVideoFormatPropertiesKHR* toMap);

 void handlemap_VkVideoPictureResourceKHR(VulkanHandleMapping* handlemap,
                                          VkVideoPictureResourceKHR* toMap);

 void handlemap_VkVideoReferenceSlotKHR(VulkanHandleMapping* handlemap,
                                        VkVideoReferenceSlotKHR* toMap);

 void handlemap_VkVideoGetMemoryPropertiesKHR(VulkanHandleMapping* handlemap,
                                              VkVideoGetMemoryPropertiesKHR* toMap);

 void handlemap_VkVideoBindMemoryKHR(VulkanHandleMapping* handlemap, VkVideoBindMemoryKHR* toMap);

 void handlemap_VkVideoSessionCreateInfoKHR(VulkanHandleMapping* handlemap,
                                            VkVideoSessionCreateInfoKHR* toMap);

 void handlemap_VkVideoSessionParametersCreateInfoKHR(VulkanHandleMapping* handlemap,
                                                      VkVideoSessionParametersCreateInfoKHR* toMap);

 void handlemap_VkVideoSessionParametersUpdateInfoKHR(VulkanHandleMapping* handlemap,
                                                      VkVideoSessionParametersUpdateInfoKHR* toMap);

 void handlemap_VkVideoBeginCodingInfoKHR(VulkanHandleMapping* handlemap,
                                          VkVideoBeginCodingInfoKHR* toMap);

 void handlemap_VkVideoEndCodingInfoKHR(VulkanHandleMapping* handlemap,
                                        VkVideoEndCodingInfoKHR* toMap);

 void handlemap_VkVideoCodingControlInfoKHR(VulkanHandleMapping* handlemap,
                                            VkVideoCodingControlInfoKHR* toMap);

 #endif
 #ifdef VK_KHR_video_decode_queue
 void handlemap_VkVideoDecodeInfoKHR(VulkanHandleMapping* handlemap, VkVideoDecodeInfoKHR* toMap);

 #endif
 #ifdef VK_KHR_dynamic_rendering
 void handlemap_VkRenderingAttachmentInfoKHR(VulkanHandleMapping* handlemap,
                                             VkRenderingAttachmentInfoKHR* toMap);

 void handlemap_VkRenderingInfoKHR(VulkanHandleMapping* handlemap, VkRenderingInfoKHR* toMap);

 void handlemap_VkPipelineRenderingCreateInfoKHR(VulkanHandleMapping* handlemap,
                                                 VkPipelineRenderingCreateInfoKHR* toMap);

 void handlemap_VkPhysicalDeviceDynamicRenderingFeaturesKHR(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceDynamicRenderingFeaturesKHR* toMap);

 void handlemap_VkCommandBufferInheritanceRenderingInfoKHR(
     VulkanHandleMapping* handlemap, VkCommandBufferInheritanceRenderingInfoKHR* toMap);

 void handlemap_VkRenderingFragmentShadingRateAttachmentInfoKHR(
     VulkanHandleMapping* handlemap, VkRenderingFragmentShadingRateAttachmentInfoKHR* toMap);

 void handlemap_VkRenderingFragmentDensityMapAttachmentInfoEXT(
     VulkanHandleMapping* handlemap, VkRenderingFragmentDensityMapAttachmentInfoEXT* toMap);

 void handlemap_VkAttachmentSampleCountInfoAMD(VulkanHandleMapping* handlemap,
                                               VkAttachmentSampleCountInfoAMD* toMap);

 DEFINE_ALIAS_FUNCTION(handlemap_VkAttachmentSampleCountInfoAMD,
                       handlemap_VkAttachmentSampleCountInfoNV)

 void handlemap_VkMultiviewPerViewAttributesInfoNVX(VulkanHandleMapping* handlemap,
                                                    VkMultiviewPerViewAttributesInfoNVX* toMap);

 #endif
 #ifdef VK_KHR_multiview
 DEFINE_ALIAS_FUNCTION(handlemap_VkRenderPassMultiviewCreateInfo,
                       handlemap_VkRenderPassMultiviewCreateInfoKHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceMultiviewFeatures,
                       handlemap_VkPhysicalDeviceMultiviewFeaturesKHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceMultiviewProperties,
                       handlemap_VkPhysicalDeviceMultiviewPropertiesKHR)

 #endif
 #ifdef VK_KHR_get_physical_device_properties2
 DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceFeatures2, handlemap_VkPhysicalDeviceFeatures2KHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceProperties2,
                       handlemap_VkPhysicalDeviceProperties2KHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkFormatProperties2, handlemap_VkFormatProperties2KHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkImageFormatProperties2, handlemap_VkImageFormatProperties2KHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceImageFormatInfo2,
                       handlemap_VkPhysicalDeviceImageFormatInfo2KHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkQueueFamilyProperties2, handlemap_VkQueueFamilyProperties2KHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceMemoryProperties2,
                       handlemap_VkPhysicalDeviceMemoryProperties2KHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkSparseImageFormatProperties2,
                       handlemap_VkSparseImageFormatProperties2KHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceSparseImageFormatInfo2,
                       handlemap_VkPhysicalDeviceSparseImageFormatInfo2KHR)

 #endif
 #ifdef VK_KHR_device_group
 DEFINE_ALIAS_FUNCTION(handlemap_VkMemoryAllocateFlagsInfo, handlemap_VkMemoryAllocateFlagsInfoKHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkDeviceGroupRenderPassBeginInfo,
                       handlemap_VkDeviceGroupRenderPassBeginInfoKHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkDeviceGroupCommandBufferBeginInfo,
                       handlemap_VkDeviceGroupCommandBufferBeginInfoKHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkDeviceGroupSubmitInfo, handlemap_VkDeviceGroupSubmitInfoKHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkDeviceGroupBindSparseInfo,
                       handlemap_VkDeviceGroupBindSparseInfoKHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkBindBufferMemoryDeviceGroupInfo,
                       handlemap_VkBindBufferMemoryDeviceGroupInfoKHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkBindImageMemoryDeviceGroupInfo,
                       handlemap_VkBindImageMemoryDeviceGroupInfoKHR)

 #endif
 #ifdef VK_KHR_shader_draw_parameters
 #endif
 #ifdef VK_KHR_maintenance1
 #endif
 #ifdef VK_KHR_device_group_creation
 DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceGroupProperties,
                       handlemap_VkPhysicalDeviceGroupPropertiesKHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkDeviceGroupDeviceCreateInfo,
                       handlemap_VkDeviceGroupDeviceCreateInfoKHR)

 #endif
 #ifdef VK_KHR_external_memory_capabilities
 DEFINE_ALIAS_FUNCTION(handlemap_VkExternalMemoryProperties, handlemap_VkExternalMemoryPropertiesKHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceExternalImageFormatInfo,
                       handlemap_VkPhysicalDeviceExternalImageFormatInfoKHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkExternalImageFormatProperties,
                       handlemap_VkExternalImageFormatPropertiesKHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceExternalBufferInfo,
                       handlemap_VkPhysicalDeviceExternalBufferInfoKHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkExternalBufferProperties, handlemap_VkExternalBufferPropertiesKHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceIDProperties,
                       handlemap_VkPhysicalDeviceIDPropertiesKHR)

 #endif
 #ifdef VK_KHR_external_memory
 DEFINE_ALIAS_FUNCTION(handlemap_VkExternalMemoryImageCreateInfo,
                       handlemap_VkExternalMemoryImageCreateInfoKHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkExternalMemoryBufferCreateInfo,
                       handlemap_VkExternalMemoryBufferCreateInfoKHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkExportMemoryAllocateInfo, handlemap_VkExportMemoryAllocateInfoKHR)

 #endif
 #ifdef VK_KHR_external_memory_win32
 void handlemap_VkImportMemoryWin32HandleInfoKHR(VulkanHandleMapping* handlemap,
                                                 VkImportMemoryWin32HandleInfoKHR* toMap);

 void handlemap_VkExportMemoryWin32HandleInfoKHR(VulkanHandleMapping* handlemap,
                                                 VkExportMemoryWin32HandleInfoKHR* toMap);

 void handlemap_VkMemoryWin32HandlePropertiesKHR(VulkanHandleMapping* handlemap,
                                                 VkMemoryWin32HandlePropertiesKHR* toMap);

 void handlemap_VkMemoryGetWin32HandleInfoKHR(VulkanHandleMapping* handlemap,
                                              VkMemoryGetWin32HandleInfoKHR* toMap);

 #endif
 #ifdef VK_KHR_external_memory_fd
 void handlemap_VkImportMemoryFdInfoKHR(VulkanHandleMapping* handlemap,
                                        VkImportMemoryFdInfoKHR* toMap);

 void handlemap_VkMemoryFdPropertiesKHR(VulkanHandleMapping* handlemap,
                                        VkMemoryFdPropertiesKHR* toMap);

 void handlemap_VkMemoryGetFdInfoKHR(VulkanHandleMapping* handlemap, VkMemoryGetFdInfoKHR* toMap);

 #endif
 #ifdef VK_KHR_win32_keyed_mutex
 void handlemap_VkWin32KeyedMutexAcquireReleaseInfoKHR(
     VulkanHandleMapping* handlemap, VkWin32KeyedMutexAcquireReleaseInfoKHR* toMap);

 #endif
 #ifdef VK_KHR_external_semaphore_capabilities
 DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceExternalSemaphoreInfo,
                       handlemap_VkPhysicalDeviceExternalSemaphoreInfoKHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkExternalSemaphoreProperties,
                       handlemap_VkExternalSemaphorePropertiesKHR)

 #endif
 #ifdef VK_KHR_external_semaphore
 DEFINE_ALIAS_FUNCTION(handlemap_VkExportSemaphoreCreateInfo,
                       handlemap_VkExportSemaphoreCreateInfoKHR)

 #endif
 #ifdef VK_KHR_external_semaphore_win32
 void handlemap_VkImportSemaphoreWin32HandleInfoKHR(VulkanHandleMapping* handlemap,
                                                    VkImportSemaphoreWin32HandleInfoKHR* toMap);

 void handlemap_VkExportSemaphoreWin32HandleInfoKHR(VulkanHandleMapping* handlemap,
                                                    VkExportSemaphoreWin32HandleInfoKHR* toMap);

 void handlemap_VkD3D12FenceSubmitInfoKHR(VulkanHandleMapping* handlemap,
                                          VkD3D12FenceSubmitInfoKHR* toMap);

 void handlemap_VkSemaphoreGetWin32HandleInfoKHR(VulkanHandleMapping* handlemap,
                                                 VkSemaphoreGetWin32HandleInfoKHR* toMap);

 #endif
 #ifdef VK_KHR_external_semaphore_fd
 void handlemap_VkImportSemaphoreFdInfoKHR(VulkanHandleMapping* handlemap,
                                           VkImportSemaphoreFdInfoKHR* toMap);

 void handlemap_VkSemaphoreGetFdInfoKHR(VulkanHandleMapping* handlemap,
                                        VkSemaphoreGetFdInfoKHR* toMap);

 #endif
 #ifdef VK_KHR_push_descriptor
 void handlemap_VkPhysicalDevicePushDescriptorPropertiesKHR(
     VulkanHandleMapping* handlemap, VkPhysicalDevicePushDescriptorPropertiesKHR* toMap);

 #endif
 #ifdef VK_KHR_shader_float16_int8
 DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceShaderFloat16Int8Features,
                       handlemap_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceShaderFloat16Int8Features,
                       handlemap_VkPhysicalDeviceFloat16Int8FeaturesKHR)

 #endif
 #ifdef VK_KHR_16bit_storage
 DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDevice16BitStorageFeatures,
                       handlemap_VkPhysicalDevice16BitStorageFeaturesKHR)

 #endif
 #ifdef VK_KHR_incremental_present
 void handlemap_VkRectLayerKHR(VulkanHandleMapping* handlemap, VkRectLayerKHR* toMap);

 void handlemap_VkPresentRegionKHR(VulkanHandleMapping* handlemap, VkPresentRegionKHR* toMap);

 void handlemap_VkPresentRegionsKHR(VulkanHandleMapping* handlemap, VkPresentRegionsKHR* toMap);

 #endif
 #ifdef VK_KHR_descriptor_update_template
 DEFINE_ALIAS_FUNCTION(handlemap_VkDescriptorUpdateTemplateEntry,
                       handlemap_VkDescriptorUpdateTemplateEntryKHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkDescriptorUpdateTemplateCreateInfo,
                       handlemap_VkDescriptorUpdateTemplateCreateInfoKHR)

 #endif
 #ifdef VK_KHR_imageless_framebuffer
 DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceImagelessFramebufferFeatures,
                       handlemap_VkPhysicalDeviceImagelessFramebufferFeaturesKHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkFramebufferAttachmentsCreateInfo,
                       handlemap_VkFramebufferAttachmentsCreateInfoKHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkFramebufferAttachmentImageInfo,
                       handlemap_VkFramebufferAttachmentImageInfoKHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkRenderPassAttachmentBeginInfo,
                       handlemap_VkRenderPassAttachmentBeginInfoKHR)

 #endif
 #ifdef VK_KHR_create_renderpass2
 DEFINE_ALIAS_FUNCTION(handlemap_VkRenderPassCreateInfo2, handlemap_VkRenderPassCreateInfo2KHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkAttachmentDescription2, handlemap_VkAttachmentDescription2KHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkAttachmentReference2, handlemap_VkAttachmentReference2KHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkSubpassDescription2, handlemap_VkSubpassDescription2KHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkSubpassDependency2, handlemap_VkSubpassDependency2KHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkSubpassBeginInfo, handlemap_VkSubpassBeginInfoKHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkSubpassEndInfo, handlemap_VkSubpassEndInfoKHR)

 #endif
 #ifdef VK_KHR_shared_presentable_image
 void handlemap_VkSharedPresentSurfaceCapabilitiesKHR(VulkanHandleMapping* handlemap,
                                                      VkSharedPresentSurfaceCapabilitiesKHR* toMap);

 #endif
 #ifdef VK_KHR_external_fence_capabilities
 DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceExternalFenceInfo,
                       handlemap_VkPhysicalDeviceExternalFenceInfoKHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkExternalFenceProperties, handlemap_VkExternalFencePropertiesKHR)

 #endif
 #ifdef VK_KHR_external_fence
 DEFINE_ALIAS_FUNCTION(handlemap_VkExportFenceCreateInfo, handlemap_VkExportFenceCreateInfoKHR)

 #endif
 #ifdef VK_KHR_external_fence_win32
 void handlemap_VkImportFenceWin32HandleInfoKHR(VulkanHandleMapping* handlemap,
                                                VkImportFenceWin32HandleInfoKHR* toMap);

 void handlemap_VkExportFenceWin32HandleInfoKHR(VulkanHandleMapping* handlemap,
                                                VkExportFenceWin32HandleInfoKHR* toMap);

 void handlemap_VkFenceGetWin32HandleInfoKHR(VulkanHandleMapping* handlemap,
                                             VkFenceGetWin32HandleInfoKHR* toMap);

 #endif
 #ifdef VK_KHR_external_fence_fd
 void handlemap_VkImportFenceFdInfoKHR(VulkanHandleMapping* handlemap,
                                       VkImportFenceFdInfoKHR* toMap);

 void handlemap_VkFenceGetFdInfoKHR(VulkanHandleMapping* handlemap, VkFenceGetFdInfoKHR* toMap);

 #endif
 #ifdef VK_KHR_performance_query
 void handlemap_VkPhysicalDevicePerformanceQueryFeaturesKHR(
     VulkanHandleMapping* handlemap, VkPhysicalDevicePerformanceQueryFeaturesKHR* toMap);

 void handlemap_VkPhysicalDevicePerformanceQueryPropertiesKHR(
     VulkanHandleMapping* handlemap, VkPhysicalDevicePerformanceQueryPropertiesKHR* toMap);

 void handlemap_VkPerformanceCounterKHR(VulkanHandleMapping* handlemap,
                                        VkPerformanceCounterKHR* toMap);

 void handlemap_VkPerformanceCounterDescriptionKHR(VulkanHandleMapping* handlemap,
                                                   VkPerformanceCounterDescriptionKHR* toMap);

 void handlemap_VkQueryPoolPerformanceCreateInfoKHR(VulkanHandleMapping* handlemap,
                                                    VkQueryPoolPerformanceCreateInfoKHR* toMap);

 void handlemap_VkPerformanceCounterResultKHR(VulkanHandleMapping* handlemap,
                                              VkPerformanceCounterResultKHR* toMap);

 void handlemap_VkAcquireProfilingLockInfoKHR(VulkanHandleMapping* handlemap,
                                              VkAcquireProfilingLockInfoKHR* toMap);

 void handlemap_VkPerformanceQuerySubmitInfoKHR(VulkanHandleMapping* handlemap,
                                                VkPerformanceQuerySubmitInfoKHR* toMap);

 #endif
 #ifdef VK_KHR_maintenance2
 DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDevicePointClippingProperties,
                       handlemap_VkPhysicalDevicePointClippingPropertiesKHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkRenderPassInputAttachmentAspectCreateInfo,
                       handlemap_VkRenderPassInputAttachmentAspectCreateInfoKHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkInputAttachmentAspectReference,
                       handlemap_VkInputAttachmentAspectReferenceKHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkImageViewUsageCreateInfo, handlemap_VkImageViewUsageCreateInfoKHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkPipelineTessellationDomainOriginStateCreateInfo,
                       handlemap_VkPipelineTessellationDomainOriginStateCreateInfoKHR)

 #endif
 #ifdef VK_KHR_get_surface_capabilities2
 void handlemap_VkPhysicalDeviceSurfaceInfo2KHR(VulkanHandleMapping* handlemap,
                                                VkPhysicalDeviceSurfaceInfo2KHR* toMap);

 void handlemap_VkSurfaceCapabilities2KHR(VulkanHandleMapping* handlemap,
                                          VkSurfaceCapabilities2KHR* toMap);

 void handlemap_VkSurfaceFormat2KHR(VulkanHandleMapping* handlemap, VkSurfaceFormat2KHR* toMap);

 #endif
 #ifdef VK_KHR_variable_pointers
 DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceVariablePointersFeatures,
                       handlemap_VkPhysicalDeviceVariablePointerFeaturesKHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceVariablePointersFeatures,
                       handlemap_VkPhysicalDeviceVariablePointersFeaturesKHR)

 #endif
 #ifdef VK_KHR_get_display_properties2
 void handlemap_VkDisplayProperties2KHR(VulkanHandleMapping* handlemap,
                                        VkDisplayProperties2KHR* toMap);

 void handlemap_VkDisplayPlaneProperties2KHR(VulkanHandleMapping* handlemap,
                                             VkDisplayPlaneProperties2KHR* toMap);

 void handlemap_VkDisplayModeProperties2KHR(VulkanHandleMapping* handlemap,
                                            VkDisplayModeProperties2KHR* toMap);

 void handlemap_VkDisplayPlaneInfo2KHR(VulkanHandleMapping* handlemap,
                                       VkDisplayPlaneInfo2KHR* toMap);

 void handlemap_VkDisplayPlaneCapabilities2KHR(VulkanHandleMapping* handlemap,
                                               VkDisplayPlaneCapabilities2KHR* toMap);

 #endif
 #ifdef VK_KHR_dedicated_allocation
 DEFINE_ALIAS_FUNCTION(handlemap_VkMemoryDedicatedRequirements,
                       handlemap_VkMemoryDedicatedRequirementsKHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkMemoryDedicatedAllocateInfo,
                       handlemap_VkMemoryDedicatedAllocateInfoKHR)

 #endif
 #ifdef VK_KHR_storage_buffer_storage_class
 #endif
 #ifdef VK_KHR_relaxed_block_layout
 #endif
 #ifdef VK_KHR_get_memory_requirements2
 DEFINE_ALIAS_FUNCTION(handlemap_VkBufferMemoryRequirementsInfo2,
                       handlemap_VkBufferMemoryRequirementsInfo2KHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkImageMemoryRequirementsInfo2,
                       handlemap_VkImageMemoryRequirementsInfo2KHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkImageSparseMemoryRequirementsInfo2,
                       handlemap_VkImageSparseMemoryRequirementsInfo2KHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkMemoryRequirements2, handlemap_VkMemoryRequirements2KHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkSparseImageMemoryRequirements2,
                       handlemap_VkSparseImageMemoryRequirements2KHR)

 #endif
 #ifdef VK_KHR_image_format_list
 DEFINE_ALIAS_FUNCTION(handlemap_VkImageFormatListCreateInfo,
                       handlemap_VkImageFormatListCreateInfoKHR)

 #endif
 #ifdef VK_KHR_sampler_ycbcr_conversion
 DEFINE_ALIAS_FUNCTION(handlemap_VkSamplerYcbcrConversionCreateInfo,
                       handlemap_VkSamplerYcbcrConversionCreateInfoKHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkSamplerYcbcrConversionInfo,
                       handlemap_VkSamplerYcbcrConversionInfoKHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkBindImagePlaneMemoryInfo, handlemap_VkBindImagePlaneMemoryInfoKHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkImagePlaneMemoryRequirementsInfo,
                       handlemap_VkImagePlaneMemoryRequirementsInfoKHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceSamplerYcbcrConversionFeatures,
                       handlemap_VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkSamplerYcbcrConversionImageFormatProperties,
                       handlemap_VkSamplerYcbcrConversionImageFormatPropertiesKHR)

 #endif
 #ifdef VK_KHR_bind_memory2
 DEFINE_ALIAS_FUNCTION(handlemap_VkBindBufferMemoryInfo, handlemap_VkBindBufferMemoryInfoKHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkBindImageMemoryInfo, handlemap_VkBindImageMemoryInfoKHR)

 #endif
 #ifdef VK_KHR_portability_subset
 void handlemap_VkPhysicalDevicePortabilitySubsetFeaturesKHR(
     VulkanHandleMapping* handlemap, VkPhysicalDevicePortabilitySubsetFeaturesKHR* toMap);

 void handlemap_VkPhysicalDevicePortabilitySubsetPropertiesKHR(
     VulkanHandleMapping* handlemap, VkPhysicalDevicePortabilitySubsetPropertiesKHR* toMap);

 #endif
 #ifdef VK_KHR_maintenance3
 DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceMaintenance3Properties,
                       handlemap_VkPhysicalDeviceMaintenance3PropertiesKHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkDescriptorSetLayoutSupport,
                       handlemap_VkDescriptorSetLayoutSupportKHR)

 #endif
 #ifdef VK_KHR_draw_indirect_count
 #endif
 #ifdef VK_KHR_shader_subgroup_extended_types
 DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures,
                       handlemap_VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR)

 #endif
 #ifdef VK_KHR_8bit_storage
 DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDevice8BitStorageFeatures,
                       handlemap_VkPhysicalDevice8BitStorageFeaturesKHR)

 #endif
 #ifdef VK_KHR_shader_atomic_int64
 DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceShaderAtomicInt64Features,
                       handlemap_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR)

 #endif
 #ifdef VK_KHR_shader_clock
 void handlemap_VkPhysicalDeviceShaderClockFeaturesKHR(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderClockFeaturesKHR* toMap);

 #endif
 #ifdef VK_KHR_driver_properties
 DEFINE_ALIAS_FUNCTION(handlemap_VkConformanceVersion, handlemap_VkConformanceVersionKHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceDriverProperties,
                       handlemap_VkPhysicalDeviceDriverPropertiesKHR)

 #endif
 #ifdef VK_KHR_shader_float_controls
 DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceFloatControlsProperties,
                       handlemap_VkPhysicalDeviceFloatControlsPropertiesKHR)

 #endif
 #ifdef VK_KHR_depth_stencil_resolve
 DEFINE_ALIAS_FUNCTION(handlemap_VkSubpassDescriptionDepthStencilResolve,
                       handlemap_VkSubpassDescriptionDepthStencilResolveKHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceDepthStencilResolveProperties,
                       handlemap_VkPhysicalDeviceDepthStencilResolvePropertiesKHR)

 #endif
 #ifdef VK_KHR_swapchain_mutable_format
 #endif
 #ifdef VK_KHR_timeline_semaphore
 DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceTimelineSemaphoreFeatures,
                       handlemap_VkPhysicalDeviceTimelineSemaphoreFeaturesKHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceTimelineSemaphoreProperties,
                       handlemap_VkPhysicalDeviceTimelineSemaphorePropertiesKHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkSemaphoreTypeCreateInfo, handlemap_VkSemaphoreTypeCreateInfoKHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkTimelineSemaphoreSubmitInfo,
                       handlemap_VkTimelineSemaphoreSubmitInfoKHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkSemaphoreWaitInfo, handlemap_VkSemaphoreWaitInfoKHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkSemaphoreSignalInfo, handlemap_VkSemaphoreSignalInfoKHR)

 #endif
 #ifdef VK_KHR_vulkan_memory_model
 DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceVulkanMemoryModelFeatures,
                       handlemap_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR)

 #endif
 #ifdef VK_KHR_shader_terminate_invocation
 void handlemap_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* toMap);

 #endif
 #ifdef VK_KHR_fragment_shading_rate
 void handlemap_VkFragmentShadingRateAttachmentInfoKHR(
     VulkanHandleMapping* handlemap, VkFragmentShadingRateAttachmentInfoKHR* toMap);

 void handlemap_VkPipelineFragmentShadingRateStateCreateInfoKHR(
     VulkanHandleMapping* handlemap, VkPipelineFragmentShadingRateStateCreateInfoKHR* toMap);

 void handlemap_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceFragmentShadingRateFeaturesKHR* toMap);

 void handlemap_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceFragmentShadingRatePropertiesKHR* toMap);

 void handlemap_VkPhysicalDeviceFragmentShadingRateKHR(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceFragmentShadingRateKHR* toMap);

 #endif
 #ifdef VK_KHR_spirv_1_4
 #endif
 #ifdef VK_KHR_surface_protected_capabilities
 void handlemap_VkSurfaceProtectedCapabilitiesKHR(VulkanHandleMapping* handlemap,
                                                  VkSurfaceProtectedCapabilitiesKHR* toMap);

 #endif
 #ifdef VK_KHR_separate_depth_stencil_layouts
 DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures,
                       handlemap_VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkAttachmentReferenceStencilLayout,
                       handlemap_VkAttachmentReferenceStencilLayoutKHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkAttachmentDescriptionStencilLayout,
                       handlemap_VkAttachmentDescriptionStencilLayoutKHR)

 #endif
 #ifdef VK_KHR_present_wait
 void handlemap_VkPhysicalDevicePresentWaitFeaturesKHR(
     VulkanHandleMapping* handlemap, VkPhysicalDevicePresentWaitFeaturesKHR* toMap);

 #endif
 #ifdef VK_KHR_uniform_buffer_standard_layout
 DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceUniformBufferStandardLayoutFeatures,
                       handlemap_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR)

 #endif
 #ifdef VK_KHR_buffer_device_address
 DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceBufferDeviceAddressFeatures,
                       handlemap_VkPhysicalDeviceBufferDeviceAddressFeaturesKHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkBufferDeviceAddressInfo, handlemap_VkBufferDeviceAddressInfoKHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkBufferOpaqueCaptureAddressCreateInfo,
                       handlemap_VkBufferOpaqueCaptureAddressCreateInfoKHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkMemoryOpaqueCaptureAddressAllocateInfo,
                       handlemap_VkMemoryOpaqueCaptureAddressAllocateInfoKHR)

 DEFINE_ALIAS_FUNCTION(handlemap_VkDeviceMemoryOpaqueCaptureAddressInfo,
                       handlemap_VkDeviceMemoryOpaqueCaptureAddressInfoKHR)

 #endif
 #ifdef VK_KHR_deferred_host_operations
 #endif
 #ifdef VK_KHR_pipeline_executable_properties
 void handlemap_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(
     VulkanHandleMapping* handlemap, VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* toMap);

 void handlemap_VkPipelineInfoKHR(VulkanHandleMapping* handlemap, VkPipelineInfoKHR* toMap);

 void handlemap_VkPipelineExecutablePropertiesKHR(VulkanHandleMapping* handlemap,
                                                  VkPipelineExecutablePropertiesKHR* toMap);

 void handlemap_VkPipelineExecutableInfoKHR(VulkanHandleMapping* handlemap,
                                            VkPipelineExecutableInfoKHR* toMap);

 void handlemap_VkPipelineExecutableStatisticValueKHR(VulkanHandleMapping* handlemap,
                                                      VkPipelineExecutableStatisticValueKHR* toMap);

 void handlemap_VkPipelineExecutableStatisticKHR(VulkanHandleMapping* handlemap,
                                                 VkPipelineExecutableStatisticKHR* toMap);

 void handlemap_VkPipelineExecutableInternalRepresentationKHR(
     VulkanHandleMapping* handlemap, VkPipelineExecutableInternalRepresentationKHR* toMap);

 #endif
 #ifdef VK_KHR_shader_integer_dot_product
 void handlemap_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR* toMap);

 void handlemap_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR* toMap);

 #endif
 #ifdef VK_KHR_pipeline_library
 void handlemap_VkPipelineLibraryCreateInfoKHR(VulkanHandleMapping* handlemap,
                                               VkPipelineLibraryCreateInfoKHR* toMap);

 #endif
 #ifdef VK_KHR_shader_non_semantic_info
 #endif
 #ifdef VK_KHR_present_id
 void handlemap_VkPresentIdKHR(VulkanHandleMapping* handlemap, VkPresentIdKHR* toMap);

 void handlemap_VkPhysicalDevicePresentIdFeaturesKHR(VulkanHandleMapping* handlemap,
                                                     VkPhysicalDevicePresentIdFeaturesKHR* toMap);

 #endif
 #ifdef VK_KHR_video_encode_queue
 void handlemap_VkVideoEncodeInfoKHR(VulkanHandleMapping* handlemap, VkVideoEncodeInfoKHR* toMap);

 void handlemap_VkVideoEncodeRateControlInfoKHR(VulkanHandleMapping* handlemap,
                                                VkVideoEncodeRateControlInfoKHR* toMap);

 #endif
 #ifdef VK_KHR_synchronization2
 void handlemap_VkMemoryBarrier2KHR(VulkanHandleMapping* handlemap, VkMemoryBarrier2KHR* toMap);

 void handlemap_VkBufferMemoryBarrier2KHR(VulkanHandleMapping* handlemap,
                                          VkBufferMemoryBarrier2KHR* toMap);

 void handlemap_VkImageMemoryBarrier2KHR(VulkanHandleMapping* handlemap,
                                         VkImageMemoryBarrier2KHR* toMap);

 void handlemap_VkDependencyInfoKHR(VulkanHandleMapping* handlemap, VkDependencyInfoKHR* toMap);

 void handlemap_VkSemaphoreSubmitInfoKHR(VulkanHandleMapping* handlemap,
                                         VkSemaphoreSubmitInfoKHR* toMap);

 void handlemap_VkCommandBufferSubmitInfoKHR(VulkanHandleMapping* handlemap,
                                             VkCommandBufferSubmitInfoKHR* toMap);

 void handlemap_VkSubmitInfo2KHR(VulkanHandleMapping* handlemap, VkSubmitInfo2KHR* toMap);

 void handlemap_VkPhysicalDeviceSynchronization2FeaturesKHR(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceSynchronization2FeaturesKHR* toMap);

 void handlemap_VkQueueFamilyCheckpointProperties2NV(VulkanHandleMapping* handlemap,
                                                     VkQueueFamilyCheckpointProperties2NV* toMap);

 void handlemap_VkCheckpointData2NV(VulkanHandleMapping* handlemap, VkCheckpointData2NV* toMap);

 #endif
 #ifdef VK_KHR_shader_subgroup_uniform_control_flow
 void handlemap_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
     VulkanHandleMapping* handlemap,
     VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* toMap);

 #endif
 #ifdef VK_KHR_zero_initialize_workgroup_memory
 void handlemap_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR(
     VulkanHandleMapping* handlemap,
     VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR* toMap);

 #endif
 #ifdef VK_KHR_workgroup_memory_explicit_layout
 void handlemap_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
     VulkanHandleMapping* handlemap,
     VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* toMap);

 #endif
 #ifdef VK_KHR_copy_commands2
 void handlemap_VkBufferCopy2KHR(VulkanHandleMapping* handlemap, VkBufferCopy2KHR* toMap);

 void handlemap_VkCopyBufferInfo2KHR(VulkanHandleMapping* handlemap, VkCopyBufferInfo2KHR* toMap);

 void handlemap_VkImageCopy2KHR(VulkanHandleMapping* handlemap, VkImageCopy2KHR* toMap);

 void handlemap_VkCopyImageInfo2KHR(VulkanHandleMapping* handlemap, VkCopyImageInfo2KHR* toMap);

 void handlemap_VkBufferImageCopy2KHR(VulkanHandleMapping* handlemap, VkBufferImageCopy2KHR* toMap);

 void handlemap_VkCopyBufferToImageInfo2KHR(VulkanHandleMapping* handlemap,
                                            VkCopyBufferToImageInfo2KHR* toMap);

 void handlemap_VkCopyImageToBufferInfo2KHR(VulkanHandleMapping* handlemap,
                                            VkCopyImageToBufferInfo2KHR* toMap);

 void handlemap_VkImageBlit2KHR(VulkanHandleMapping* handlemap, VkImageBlit2KHR* toMap);

 void handlemap_VkBlitImageInfo2KHR(VulkanHandleMapping* handlemap, VkBlitImageInfo2KHR* toMap);

 void handlemap_VkImageResolve2KHR(VulkanHandleMapping* handlemap, VkImageResolve2KHR* toMap);

 void handlemap_VkResolveImageInfo2KHR(VulkanHandleMapping* handlemap,
                                       VkResolveImageInfo2KHR* toMap);

 #endif
 #ifdef VK_KHR_format_feature_flags2
 void handlemap_VkFormatProperties3KHR(VulkanHandleMapping* handlemap,
                                       VkFormatProperties3KHR* toMap);

 #endif
 #ifdef VK_KHR_maintenance4
 void handlemap_VkPhysicalDeviceMaintenance4FeaturesKHR(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceMaintenance4FeaturesKHR* toMap);

 void handlemap_VkPhysicalDeviceMaintenance4PropertiesKHR(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceMaintenance4PropertiesKHR* toMap);

 void handlemap_VkDeviceBufferMemoryRequirementsKHR(VulkanHandleMapping* handlemap,
                                                    VkDeviceBufferMemoryRequirementsKHR* toMap);

 void handlemap_VkDeviceImageMemoryRequirementsKHR(VulkanHandleMapping* handlemap,
                                                   VkDeviceImageMemoryRequirementsKHR* toMap);

 #endif
 #ifdef VK_ANDROID_native_buffer
 void handlemap_VkNativeBufferANDROID(VulkanHandleMapping* handlemap, VkNativeBufferANDROID* toMap);

 #endif
 #ifdef VK_EXT_debug_report
 void handlemap_VkDebugReportCallbackCreateInfoEXT(VulkanHandleMapping* handlemap,
                                                   VkDebugReportCallbackCreateInfoEXT* toMap);

 #endif
 #ifdef VK_NV_glsl_shader
 #endif
 #ifdef VK_EXT_depth_range_unrestricted
 #endif
 #ifdef VK_IMG_filter_cubic
 #endif
 #ifdef VK_AMD_rasterization_order
 void handlemap_VkPipelineRasterizationStateRasterizationOrderAMD(
     VulkanHandleMapping* handlemap, VkPipelineRasterizationStateRasterizationOrderAMD* toMap);

 #endif
 #ifdef VK_AMD_shader_trinary_minmax
 #endif
 #ifdef VK_AMD_shader_explicit_vertex_parameter
 #endif
 #ifdef VK_EXT_debug_marker
 void handlemap_VkDebugMarkerObjectNameInfoEXT(VulkanHandleMapping* handlemap,
                                               VkDebugMarkerObjectNameInfoEXT* toMap);

 void handlemap_VkDebugMarkerObjectTagInfoEXT(VulkanHandleMapping* handlemap,
                                              VkDebugMarkerObjectTagInfoEXT* toMap);

 void handlemap_VkDebugMarkerMarkerInfoEXT(VulkanHandleMapping* handlemap,
                                           VkDebugMarkerMarkerInfoEXT* toMap);

 #endif
 #ifdef VK_AMD_gcn_shader
 #endif
 #ifdef VK_NV_dedicated_allocation
 void handlemap_VkDedicatedAllocationImageCreateInfoNV(
     VulkanHandleMapping* handlemap, VkDedicatedAllocationImageCreateInfoNV* toMap);

 void handlemap_VkDedicatedAllocationBufferCreateInfoNV(
     VulkanHandleMapping* handlemap, VkDedicatedAllocationBufferCreateInfoNV* toMap);

 void handlemap_VkDedicatedAllocationMemoryAllocateInfoNV(
     VulkanHandleMapping* handlemap, VkDedicatedAllocationMemoryAllocateInfoNV* toMap);

 #endif
 #ifdef VK_EXT_transform_feedback
 void handlemap_VkPhysicalDeviceTransformFeedbackFeaturesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceTransformFeedbackFeaturesEXT* toMap);

 void handlemap_VkPhysicalDeviceTransformFeedbackPropertiesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceTransformFeedbackPropertiesEXT* toMap);

 void handlemap_VkPipelineRasterizationStateStreamCreateInfoEXT(
     VulkanHandleMapping* handlemap, VkPipelineRasterizationStateStreamCreateInfoEXT* toMap);

 #endif
 #ifdef VK_NVX_binary_import
 void handlemap_VkCuModuleCreateInfoNVX(VulkanHandleMapping* handlemap,
                                        VkCuModuleCreateInfoNVX* toMap);

 void handlemap_VkCuFunctionCreateInfoNVX(VulkanHandleMapping* handlemap,
                                          VkCuFunctionCreateInfoNVX* toMap);

 void handlemap_VkCuLaunchInfoNVX(VulkanHandleMapping* handlemap, VkCuLaunchInfoNVX* toMap);

 #endif
 #ifdef VK_NVX_image_view_handle
 void handlemap_VkImageViewHandleInfoNVX(VulkanHandleMapping* handlemap,
                                         VkImageViewHandleInfoNVX* toMap);

 void handlemap_VkImageViewAddressPropertiesNVX(VulkanHandleMapping* handlemap,
                                                VkImageViewAddressPropertiesNVX* toMap);

 #endif
 #ifdef VK_AMD_draw_indirect_count
 #endif
 #ifdef VK_AMD_negative_viewport_height
 #endif
 #ifdef VK_AMD_gpu_shader_half_float
 #endif
 #ifdef VK_AMD_shader_ballot
 #endif
 #ifdef VK_EXT_video_encode_h264
 void handlemap_VkVideoEncodeH264CapabilitiesEXT(VulkanHandleMapping* handlemap,
                                                 VkVideoEncodeH264CapabilitiesEXT* toMap);

 void handlemap_VkVideoEncodeH264SessionCreateInfoEXT(VulkanHandleMapping* handlemap,
                                                      VkVideoEncodeH264SessionCreateInfoEXT* toMap);

 void handlemap_VkVideoEncodeH264SessionParametersAddInfoEXT(
     VulkanHandleMapping* handlemap, VkVideoEncodeH264SessionParametersAddInfoEXT* toMap);

 void handlemap_VkVideoEncodeH264SessionParametersCreateInfoEXT(
     VulkanHandleMapping* handlemap, VkVideoEncodeH264SessionParametersCreateInfoEXT* toMap);

 void handlemap_VkVideoEncodeH264DpbSlotInfoEXT(VulkanHandleMapping* handlemap,
                                                VkVideoEncodeH264DpbSlotInfoEXT* toMap);

 void handlemap_VkVideoEncodeH264NaluSliceEXT(VulkanHandleMapping* handlemap,
                                              VkVideoEncodeH264NaluSliceEXT* toMap);

 void handlemap_VkVideoEncodeH264VclFrameInfoEXT(VulkanHandleMapping* handlemap,
                                                 VkVideoEncodeH264VclFrameInfoEXT* toMap);

 void handlemap_VkVideoEncodeH264EmitPictureParametersEXT(
     VulkanHandleMapping* handlemap, VkVideoEncodeH264EmitPictureParametersEXT* toMap);

 void handlemap_VkVideoEncodeH264ProfileEXT(VulkanHandleMapping* handlemap,
                                            VkVideoEncodeH264ProfileEXT* toMap);

 #endif
 #ifdef VK_EXT_video_encode_h265
 void handlemap_VkVideoEncodeH265CapabilitiesEXT(VulkanHandleMapping* handlemap,
                                                 VkVideoEncodeH265CapabilitiesEXT* toMap);

 void handlemap_VkVideoEncodeH265SessionCreateInfoEXT(VulkanHandleMapping* handlemap,
                                                      VkVideoEncodeH265SessionCreateInfoEXT* toMap);

 void handlemap_VkVideoEncodeH265SessionParametersAddInfoEXT(
     VulkanHandleMapping* handlemap, VkVideoEncodeH265SessionParametersAddInfoEXT* toMap);

 void handlemap_VkVideoEncodeH265SessionParametersCreateInfoEXT(
     VulkanHandleMapping* handlemap, VkVideoEncodeH265SessionParametersCreateInfoEXT* toMap);

 void handlemap_VkVideoEncodeH265DpbSlotInfoEXT(VulkanHandleMapping* handlemap,
                                                VkVideoEncodeH265DpbSlotInfoEXT* toMap);

 void handlemap_VkVideoEncodeH265ReferenceListsEXT(VulkanHandleMapping* handlemap,
                                                   VkVideoEncodeH265ReferenceListsEXT* toMap);

 void handlemap_VkVideoEncodeH265NaluSliceEXT(VulkanHandleMapping* handlemap,
                                              VkVideoEncodeH265NaluSliceEXT* toMap);

 void handlemap_VkVideoEncodeH265VclFrameInfoEXT(VulkanHandleMapping* handlemap,
                                                 VkVideoEncodeH265VclFrameInfoEXT* toMap);

 void handlemap_VkVideoEncodeH265EmitPictureParametersEXT(
     VulkanHandleMapping* handlemap, VkVideoEncodeH265EmitPictureParametersEXT* toMap);

 void handlemap_VkVideoEncodeH265ProfileEXT(VulkanHandleMapping* handlemap,
                                            VkVideoEncodeH265ProfileEXT* toMap);

 #endif
 #ifdef VK_EXT_video_decode_h264
 void handlemap_VkVideoDecodeH264ProfileEXT(VulkanHandleMapping* handlemap,
                                            VkVideoDecodeH264ProfileEXT* toMap);

 void handlemap_VkVideoDecodeH264CapabilitiesEXT(VulkanHandleMapping* handlemap,
                                                 VkVideoDecodeH264CapabilitiesEXT* toMap);

 void handlemap_VkVideoDecodeH264SessionCreateInfoEXT(VulkanHandleMapping* handlemap,
                                                      VkVideoDecodeH264SessionCreateInfoEXT* toMap);

 void handlemap_VkVideoDecodeH264SessionParametersAddInfoEXT(
     VulkanHandleMapping* handlemap, VkVideoDecodeH264SessionParametersAddInfoEXT* toMap);

 void handlemap_VkVideoDecodeH264SessionParametersCreateInfoEXT(
     VulkanHandleMapping* handlemap, VkVideoDecodeH264SessionParametersCreateInfoEXT* toMap);

 void handlemap_VkVideoDecodeH264PictureInfoEXT(VulkanHandleMapping* handlemap,
                                                VkVideoDecodeH264PictureInfoEXT* toMap);

 void handlemap_VkVideoDecodeH264MvcEXT(VulkanHandleMapping* handlemap,
                                        VkVideoDecodeH264MvcEXT* toMap);

 void handlemap_VkVideoDecodeH264DpbSlotInfoEXT(VulkanHandleMapping* handlemap,
                                                VkVideoDecodeH264DpbSlotInfoEXT* toMap);

 #endif
 #ifdef VK_AMD_texture_gather_bias_lod
 void handlemap_VkTextureLODGatherFormatPropertiesAMD(VulkanHandleMapping* handlemap,
                                                      VkTextureLODGatherFormatPropertiesAMD* toMap);

 #endif
 #ifdef VK_AMD_shader_info
 void handlemap_VkShaderResourceUsageAMD(VulkanHandleMapping* handlemap,
                                         VkShaderResourceUsageAMD* toMap);

 void handlemap_VkShaderStatisticsInfoAMD(VulkanHandleMapping* handlemap,
                                          VkShaderStatisticsInfoAMD* toMap);

 #endif
 #ifdef VK_AMD_shader_image_load_store_lod
 #endif
 #ifdef VK_GGP_stream_descriptor_surface
 void handlemap_VkStreamDescriptorSurfaceCreateInfoGGP(
     VulkanHandleMapping* handlemap, VkStreamDescriptorSurfaceCreateInfoGGP* toMap);

 #endif
 #ifdef VK_NV_corner_sampled_image
 void handlemap_VkPhysicalDeviceCornerSampledImageFeaturesNV(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceCornerSampledImageFeaturesNV* toMap);

 #endif
 #ifdef VK_IMG_format_pvrtc
 #endif
 #ifdef VK_NV_external_memory_capabilities
 void handlemap_VkExternalImageFormatPropertiesNV(VulkanHandleMapping* handlemap,
                                                  VkExternalImageFormatPropertiesNV* toMap);

 #endif
 #ifdef VK_NV_external_memory
 void handlemap_VkExternalMemoryImageCreateInfoNV(VulkanHandleMapping* handlemap,
                                                  VkExternalMemoryImageCreateInfoNV* toMap);

 void handlemap_VkExportMemoryAllocateInfoNV(VulkanHandleMapping* handlemap,
                                             VkExportMemoryAllocateInfoNV* toMap);

 #endif
 #ifdef VK_NV_external_memory_win32
 void handlemap_VkImportMemoryWin32HandleInfoNV(VulkanHandleMapping* handlemap,
                                                VkImportMemoryWin32HandleInfoNV* toMap);

 void handlemap_VkExportMemoryWin32HandleInfoNV(VulkanHandleMapping* handlemap,
                                                VkExportMemoryWin32HandleInfoNV* toMap);

 #endif
 #ifdef VK_NV_win32_keyed_mutex
 void handlemap_VkWin32KeyedMutexAcquireReleaseInfoNV(VulkanHandleMapping* handlemap,
                                                      VkWin32KeyedMutexAcquireReleaseInfoNV* toMap);

 #endif
 #ifdef VK_EXT_validation_flags
 void handlemap_VkValidationFlagsEXT(VulkanHandleMapping* handlemap, VkValidationFlagsEXT* toMap);

 #endif
 #ifdef VK_NN_vi_surface
 void handlemap_VkViSurfaceCreateInfoNN(VulkanHandleMapping* handlemap,
                                        VkViSurfaceCreateInfoNN* toMap);

 #endif
 #ifdef VK_EXT_shader_subgroup_ballot
 #endif
 #ifdef VK_EXT_shader_subgroup_vote
 #endif
 #ifdef VK_EXT_texture_compression_astc_hdr
 void handlemap_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* toMap);

 #endif
 #ifdef VK_EXT_astc_decode_mode
 void handlemap_VkImageViewASTCDecodeModeEXT(VulkanHandleMapping* handlemap,
                                             VkImageViewASTCDecodeModeEXT* toMap);

 void handlemap_VkPhysicalDeviceASTCDecodeFeaturesEXT(VulkanHandleMapping* handlemap,
                                                      VkPhysicalDeviceASTCDecodeFeaturesEXT* toMap);

 #endif
 #ifdef VK_EXT_conditional_rendering
 void handlemap_VkConditionalRenderingBeginInfoEXT(VulkanHandleMapping* handlemap,
                                                   VkConditionalRenderingBeginInfoEXT* toMap);

 void handlemap_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceConditionalRenderingFeaturesEXT* toMap);

 void handlemap_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
     VulkanHandleMapping* handlemap, VkCommandBufferInheritanceConditionalRenderingInfoEXT* toMap);

 #endif
 #ifdef VK_NV_clip_space_w_scaling
 void handlemap_VkViewportWScalingNV(VulkanHandleMapping* handlemap, VkViewportWScalingNV* toMap);

 void handlemap_VkPipelineViewportWScalingStateCreateInfoNV(
     VulkanHandleMapping* handlemap, VkPipelineViewportWScalingStateCreateInfoNV* toMap);

 #endif
 #ifdef VK_EXT_direct_mode_display
 #endif
 #ifdef VK_EXT_acquire_xlib_display
 #endif
 #ifdef VK_EXT_display_surface_counter
 void handlemap_VkSurfaceCapabilities2EXT(VulkanHandleMapping* handlemap,
                                          VkSurfaceCapabilities2EXT* toMap);

 #endif
 #ifdef VK_EXT_display_control
 void handlemap_VkDisplayPowerInfoEXT(VulkanHandleMapping* handlemap, VkDisplayPowerInfoEXT* toMap);

 void handlemap_VkDeviceEventInfoEXT(VulkanHandleMapping* handlemap, VkDeviceEventInfoEXT* toMap);

 void handlemap_VkDisplayEventInfoEXT(VulkanHandleMapping* handlemap, VkDisplayEventInfoEXT* toMap);

 void handlemap_VkSwapchainCounterCreateInfoEXT(VulkanHandleMapping* handlemap,
                                                VkSwapchainCounterCreateInfoEXT* toMap);

 #endif
 #ifdef VK_GOOGLE_display_timing
 void handlemap_VkRefreshCycleDurationGOOGLE(VulkanHandleMapping* handlemap,
                                             VkRefreshCycleDurationGOOGLE* toMap);

 void handlemap_VkPastPresentationTimingGOOGLE(VulkanHandleMapping* handlemap,
                                               VkPastPresentationTimingGOOGLE* toMap);

 void handlemap_VkPresentTimeGOOGLE(VulkanHandleMapping* handlemap, VkPresentTimeGOOGLE* toMap);

 void handlemap_VkPresentTimesInfoGOOGLE(VulkanHandleMapping* handlemap,
                                         VkPresentTimesInfoGOOGLE* toMap);

 #endif
 #ifdef VK_NV_sample_mask_override_coverage
 #endif
 #ifdef VK_NV_geometry_shader_passthrough
 #endif
 #ifdef VK_NV_viewport_array2
 #endif
 #ifdef VK_NVX_multiview_per_view_attributes
 void handlemap_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* toMap);

 #endif
 #ifdef VK_NV_viewport_swizzle
 void handlemap_VkViewportSwizzleNV(VulkanHandleMapping* handlemap, VkViewportSwizzleNV* toMap);

 void handlemap_VkPipelineViewportSwizzleStateCreateInfoNV(
     VulkanHandleMapping* handlemap, VkPipelineViewportSwizzleStateCreateInfoNV* toMap);

 #endif
 #ifdef VK_EXT_discard_rectangles
 void handlemap_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceDiscardRectanglePropertiesEXT* toMap);

 void handlemap_VkPipelineDiscardRectangleStateCreateInfoEXT(
     VulkanHandleMapping* handlemap, VkPipelineDiscardRectangleStateCreateInfoEXT* toMap);

 #endif
 #ifdef VK_EXT_conservative_rasterization
 void handlemap_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceConservativeRasterizationPropertiesEXT* toMap);

 void handlemap_VkPipelineRasterizationConservativeStateCreateInfoEXT(
     VulkanHandleMapping* handlemap, VkPipelineRasterizationConservativeStateCreateInfoEXT* toMap);

 #endif
 #ifdef VK_EXT_depth_clip_enable
 void handlemap_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceDepthClipEnableFeaturesEXT* toMap);

 void handlemap_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
     VulkanHandleMapping* handlemap, VkPipelineRasterizationDepthClipStateCreateInfoEXT* toMap);

 #endif
 #ifdef VK_EXT_swapchain_colorspace
 #endif
 #ifdef VK_EXT_hdr_metadata
 void handlemap_VkXYColorEXT(VulkanHandleMapping* handlemap, VkXYColorEXT* toMap);

 void handlemap_VkHdrMetadataEXT(VulkanHandleMapping* handlemap, VkHdrMetadataEXT* toMap);

 #endif
 #ifdef VK_MVK_ios_surface
 void handlemap_VkIOSSurfaceCreateInfoMVK(VulkanHandleMapping* handlemap,
                                          VkIOSSurfaceCreateInfoMVK* toMap);

 #endif
 #ifdef VK_MVK_macos_surface
 void handlemap_VkMacOSSurfaceCreateInfoMVK(VulkanHandleMapping* handlemap,
                                            VkMacOSSurfaceCreateInfoMVK* toMap);

 #endif
 #ifdef VK_MVK_moltenvk
 #endif
 #ifdef VK_EXT_external_memory_dma_buf
 #endif
 #ifdef VK_EXT_queue_family_foreign
 #endif
 #ifdef VK_EXT_debug_utils
 void handlemap_VkDebugUtilsLabelEXT(VulkanHandleMapping* handlemap, VkDebugUtilsLabelEXT* toMap);

 void handlemap_VkDebugUtilsObjectNameInfoEXT(VulkanHandleMapping* handlemap,
                                              VkDebugUtilsObjectNameInfoEXT* toMap);

 void handlemap_VkDebugUtilsMessengerCallbackDataEXT(VulkanHandleMapping* handlemap,
                                                     VkDebugUtilsMessengerCallbackDataEXT* toMap);

 void handlemap_VkDebugUtilsMessengerCreateInfoEXT(VulkanHandleMapping* handlemap,
                                                   VkDebugUtilsMessengerCreateInfoEXT* toMap);

 void handlemap_VkDebugUtilsObjectTagInfoEXT(VulkanHandleMapping* handlemap,
                                             VkDebugUtilsObjectTagInfoEXT* toMap);

 #endif
 #ifdef VK_ANDROID_external_memory_android_hardware_buffer
 void handlemap_VkAndroidHardwareBufferUsageANDROID(VulkanHandleMapping* handlemap,
                                                    VkAndroidHardwareBufferUsageANDROID* toMap);

 void handlemap_VkAndroidHardwareBufferPropertiesANDROID(
     VulkanHandleMapping* handlemap, VkAndroidHardwareBufferPropertiesANDROID* toMap);

 void handlemap_VkAndroidHardwareBufferFormatPropertiesANDROID(
     VulkanHandleMapping* handlemap, VkAndroidHardwareBufferFormatPropertiesANDROID* toMap);

 void handlemap_VkImportAndroidHardwareBufferInfoANDROID(
     VulkanHandleMapping* handlemap, VkImportAndroidHardwareBufferInfoANDROID* toMap);

 void handlemap_VkMemoryGetAndroidHardwareBufferInfoANDROID(
     VulkanHandleMapping* handlemap, VkMemoryGetAndroidHardwareBufferInfoANDROID* toMap);

 void handlemap_VkExternalFormatANDROID(VulkanHandleMapping* handlemap,
                                        VkExternalFormatANDROID* toMap);

 void handlemap_VkAndroidHardwareBufferFormatProperties2ANDROID(
     VulkanHandleMapping* handlemap, VkAndroidHardwareBufferFormatProperties2ANDROID* toMap);

 #endif
 #ifdef VK_EXT_sampler_filter_minmax
 DEFINE_ALIAS_FUNCTION(handlemap_VkSamplerReductionModeCreateInfo,
                       handlemap_VkSamplerReductionModeCreateInfoEXT)

 DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceSamplerFilterMinmaxProperties,
                       handlemap_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT)

 #endif
 #ifdef VK_AMD_gpu_shader_int16
 #endif
 #ifdef VK_AMD_mixed_attachment_samples
 #endif
 #ifdef VK_AMD_shader_fragment_mask
 #endif
 #ifdef VK_EXT_inline_uniform_block
 void handlemap_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceInlineUniformBlockFeaturesEXT* toMap);

 void handlemap_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceInlineUniformBlockPropertiesEXT* toMap);

 void handlemap_VkWriteDescriptorSetInlineUniformBlockEXT(
     VulkanHandleMapping* handlemap, VkWriteDescriptorSetInlineUniformBlockEXT* toMap);

 void handlemap_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
     VulkanHandleMapping* handlemap, VkDescriptorPoolInlineUniformBlockCreateInfoEXT* toMap);

 #endif
 #ifdef VK_EXT_shader_stencil_export
 #endif
 #ifdef VK_EXT_sample_locations
 void handlemap_VkSampleLocationEXT(VulkanHandleMapping* handlemap, VkSampleLocationEXT* toMap);

 void handlemap_VkSampleLocationsInfoEXT(VulkanHandleMapping* handlemap,
                                         VkSampleLocationsInfoEXT* toMap);

 void handlemap_VkAttachmentSampleLocationsEXT(VulkanHandleMapping* handlemap,
                                               VkAttachmentSampleLocationsEXT* toMap);

 void handlemap_VkSubpassSampleLocationsEXT(VulkanHandleMapping* handlemap,
                                            VkSubpassSampleLocationsEXT* toMap);

 void handlemap_VkRenderPassSampleLocationsBeginInfoEXT(
     VulkanHandleMapping* handlemap, VkRenderPassSampleLocationsBeginInfoEXT* toMap);

 void handlemap_VkPipelineSampleLocationsStateCreateInfoEXT(
     VulkanHandleMapping* handlemap, VkPipelineSampleLocationsStateCreateInfoEXT* toMap);

 void handlemap_VkPhysicalDeviceSampleLocationsPropertiesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceSampleLocationsPropertiesEXT* toMap);

 void handlemap_VkMultisamplePropertiesEXT(VulkanHandleMapping* handlemap,
                                           VkMultisamplePropertiesEXT* toMap);

 #endif
 #ifdef VK_EXT_blend_operation_advanced
 void handlemap_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* toMap);

 void handlemap_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* toMap);

 void handlemap_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
     VulkanHandleMapping* handlemap, VkPipelineColorBlendAdvancedStateCreateInfoEXT* toMap);

 #endif
 #ifdef VK_NV_fragment_coverage_to_color
 void handlemap_VkPipelineCoverageToColorStateCreateInfoNV(
     VulkanHandleMapping* handlemap, VkPipelineCoverageToColorStateCreateInfoNV* toMap);

 #endif
 #ifdef VK_NV_framebuffer_mixed_samples
 void handlemap_VkPipelineCoverageModulationStateCreateInfoNV(
     VulkanHandleMapping* handlemap, VkPipelineCoverageModulationStateCreateInfoNV* toMap);

 #endif
 #ifdef VK_NV_fill_rectangle
 #endif
 #ifdef VK_NV_shader_sm_builtins
 void handlemap_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* toMap);

 void handlemap_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* toMap);

 #endif
 #ifdef VK_EXT_post_depth_coverage
 #endif
 #ifdef VK_EXT_image_drm_format_modifier
 void handlemap_VkDrmFormatModifierPropertiesEXT(VulkanHandleMapping* handlemap,
                                                 VkDrmFormatModifierPropertiesEXT* toMap);

 void handlemap_VkDrmFormatModifierPropertiesListEXT(VulkanHandleMapping* handlemap,
                                                     VkDrmFormatModifierPropertiesListEXT* toMap);

 void handlemap_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceImageDrmFormatModifierInfoEXT* toMap);

 void handlemap_VkImageDrmFormatModifierListCreateInfoEXT(
     VulkanHandleMapping* handlemap, VkImageDrmFormatModifierListCreateInfoEXT* toMap);

 void handlemap_VkImageDrmFormatModifierExplicitCreateInfoEXT(
     VulkanHandleMapping* handlemap, VkImageDrmFormatModifierExplicitCreateInfoEXT* toMap);

 void handlemap_VkImageDrmFormatModifierPropertiesEXT(VulkanHandleMapping* handlemap,
                                                      VkImageDrmFormatModifierPropertiesEXT* toMap);

 void handlemap_VkDrmFormatModifierProperties2EXT(VulkanHandleMapping* handlemap,
                                                  VkDrmFormatModifierProperties2EXT* toMap);

 void handlemap_VkDrmFormatModifierPropertiesList2EXT(VulkanHandleMapping* handlemap,
                                                      VkDrmFormatModifierPropertiesList2EXT* toMap);

 #endif
 #ifdef VK_EXT_validation_cache
 void handlemap_VkValidationCacheCreateInfoEXT(VulkanHandleMapping* handlemap,
                                               VkValidationCacheCreateInfoEXT* toMap);

 void handlemap_VkShaderModuleValidationCacheCreateInfoEXT(
     VulkanHandleMapping* handlemap, VkShaderModuleValidationCacheCreateInfoEXT* toMap);

 #endif
 #ifdef VK_EXT_descriptor_indexing
 DEFINE_ALIAS_FUNCTION(handlemap_VkDescriptorSetLayoutBindingFlagsCreateInfo,
                       handlemap_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT)

 DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceDescriptorIndexingFeatures,
                       handlemap_VkPhysicalDeviceDescriptorIndexingFeaturesEXT)

 DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceDescriptorIndexingProperties,
                       handlemap_VkPhysicalDeviceDescriptorIndexingPropertiesEXT)

 DEFINE_ALIAS_FUNCTION(handlemap_VkDescriptorSetVariableDescriptorCountAllocateInfo,
                       handlemap_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT)

 DEFINE_ALIAS_FUNCTION(handlemap_VkDescriptorSetVariableDescriptorCountLayoutSupport,
                       handlemap_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT)

 #endif
 #ifdef VK_EXT_shader_viewport_index_layer
 #endif
 #ifdef VK_NV_shading_rate_image
 void handlemap_VkShadingRatePaletteNV(VulkanHandleMapping* handlemap,
                                       VkShadingRatePaletteNV* toMap);

 void handlemap_VkPipelineViewportShadingRateImageStateCreateInfoNV(
     VulkanHandleMapping* handlemap, VkPipelineViewportShadingRateImageStateCreateInfoNV* toMap);

 void handlemap_VkPhysicalDeviceShadingRateImageFeaturesNV(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceShadingRateImageFeaturesNV* toMap);

 void handlemap_VkPhysicalDeviceShadingRateImagePropertiesNV(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceShadingRateImagePropertiesNV* toMap);

 void handlemap_VkCoarseSampleLocationNV(VulkanHandleMapping* handlemap,
                                         VkCoarseSampleLocationNV* toMap);

 void handlemap_VkCoarseSampleOrderCustomNV(VulkanHandleMapping* handlemap,
                                            VkCoarseSampleOrderCustomNV* toMap);

 void handlemap_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(
     VulkanHandleMapping* handlemap, VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* toMap);

 #endif
 #ifdef VK_NV_ray_tracing
 void handlemap_VkRayTracingShaderGroupCreateInfoNV(VulkanHandleMapping* handlemap,
                                                    VkRayTracingShaderGroupCreateInfoNV* toMap);

 void handlemap_VkRayTracingPipelineCreateInfoNV(VulkanHandleMapping* handlemap,
                                                 VkRayTracingPipelineCreateInfoNV* toMap);

 void handlemap_VkGeometryTrianglesNV(VulkanHandleMapping* handlemap, VkGeometryTrianglesNV* toMap);

 void handlemap_VkGeometryAABBNV(VulkanHandleMapping* handlemap, VkGeometryAABBNV* toMap);

 void handlemap_VkGeometryDataNV(VulkanHandleMapping* handlemap, VkGeometryDataNV* toMap);

 void handlemap_VkGeometryNV(VulkanHandleMapping* handlemap, VkGeometryNV* toMap);

 void handlemap_VkAccelerationStructureInfoNV(VulkanHandleMapping* handlemap,
                                              VkAccelerationStructureInfoNV* toMap);

 void handlemap_VkAccelerationStructureCreateInfoNV(VulkanHandleMapping* handlemap,
                                                    VkAccelerationStructureCreateInfoNV* toMap);

 void handlemap_VkBindAccelerationStructureMemoryInfoNV(
     VulkanHandleMapping* handlemap, VkBindAccelerationStructureMemoryInfoNV* toMap);

 void handlemap_VkWriteDescriptorSetAccelerationStructureNV(
     VulkanHandleMapping* handlemap, VkWriteDescriptorSetAccelerationStructureNV* toMap);

 void handlemap_VkAccelerationStructureMemoryRequirementsInfoNV(
     VulkanHandleMapping* handlemap, VkAccelerationStructureMemoryRequirementsInfoNV* toMap);

 void handlemap_VkPhysicalDeviceRayTracingPropertiesNV(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceRayTracingPropertiesNV* toMap);

 void handlemap_VkTransformMatrixKHR(VulkanHandleMapping* handlemap, VkTransformMatrixKHR* toMap);

 DEFINE_ALIAS_FUNCTION(handlemap_VkTransformMatrixKHR, handlemap_VkTransformMatrixNV)

 void handlemap_VkAabbPositionsKHR(VulkanHandleMapping* handlemap, VkAabbPositionsKHR* toMap);

 DEFINE_ALIAS_FUNCTION(handlemap_VkAabbPositionsKHR, handlemap_VkAabbPositionsNV)

 void handlemap_VkAccelerationStructureInstanceKHR(VulkanHandleMapping* handlemap,
                                                   VkAccelerationStructureInstanceKHR* toMap);

 DEFINE_ALIAS_FUNCTION(handlemap_VkAccelerationStructureInstanceKHR,
                       handlemap_VkAccelerationStructureInstanceNV)

 #endif
 #ifdef VK_NV_representative_fragment_test
 void handlemap_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* toMap);

 void handlemap_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(
     VulkanHandleMapping* handlemap, VkPipelineRepresentativeFragmentTestStateCreateInfoNV* toMap);

 #endif
 #ifdef VK_EXT_filter_cubic
 void handlemap_VkPhysicalDeviceImageViewImageFormatInfoEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceImageViewImageFormatInfoEXT* toMap);

 void handlemap_VkFilterCubicImageViewImageFormatPropertiesEXT(
     VulkanHandleMapping* handlemap, VkFilterCubicImageViewImageFormatPropertiesEXT* toMap);

 #endif
 #ifdef VK_QCOM_render_pass_shader_resolve
 #endif
 #ifdef VK_EXT_global_priority
 void handlemap_VkDeviceQueueGlobalPriorityCreateInfoEXT(
     VulkanHandleMapping* handlemap, VkDeviceQueueGlobalPriorityCreateInfoEXT* toMap);

 #endif
 #ifdef VK_EXT_external_memory_host
 void handlemap_VkImportMemoryHostPointerInfoEXT(VulkanHandleMapping* handlemap,
                                                 VkImportMemoryHostPointerInfoEXT* toMap);

 void handlemap_VkMemoryHostPointerPropertiesEXT(VulkanHandleMapping* handlemap,
                                                 VkMemoryHostPointerPropertiesEXT* toMap);

 void handlemap_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceExternalMemoryHostPropertiesEXT* toMap);

 #endif
 #ifdef VK_AMD_buffer_marker
 #endif
 #ifdef VK_AMD_pipeline_compiler_control
 void handlemap_VkPipelineCompilerControlCreateInfoAMD(
     VulkanHandleMapping* handlemap, VkPipelineCompilerControlCreateInfoAMD* toMap);

 #endif
 #ifdef VK_EXT_calibrated_timestamps
 void handlemap_VkCalibratedTimestampInfoEXT(VulkanHandleMapping* handlemap,
                                             VkCalibratedTimestampInfoEXT* toMap);

 #endif
 #ifdef VK_AMD_shader_core_properties
 void handlemap_VkPhysicalDeviceShaderCorePropertiesAMD(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderCorePropertiesAMD* toMap);

 #endif
 #ifdef VK_EXT_video_decode_h265
 void handlemap_VkVideoDecodeH265ProfileEXT(VulkanHandleMapping* handlemap,
                                            VkVideoDecodeH265ProfileEXT* toMap);

 void handlemap_VkVideoDecodeH265CapabilitiesEXT(VulkanHandleMapping* handlemap,
                                                 VkVideoDecodeH265CapabilitiesEXT* toMap);

 void handlemap_VkVideoDecodeH265SessionCreateInfoEXT(VulkanHandleMapping* handlemap,
                                                      VkVideoDecodeH265SessionCreateInfoEXT* toMap);

 void handlemap_VkVideoDecodeH265SessionParametersAddInfoEXT(
     VulkanHandleMapping* handlemap, VkVideoDecodeH265SessionParametersAddInfoEXT* toMap);

 void handlemap_VkVideoDecodeH265SessionParametersCreateInfoEXT(
     VulkanHandleMapping* handlemap, VkVideoDecodeH265SessionParametersCreateInfoEXT* toMap);

 void handlemap_VkVideoDecodeH265PictureInfoEXT(VulkanHandleMapping* handlemap,
                                                VkVideoDecodeH265PictureInfoEXT* toMap);

 void handlemap_VkVideoDecodeH265DpbSlotInfoEXT(VulkanHandleMapping* handlemap,
                                                VkVideoDecodeH265DpbSlotInfoEXT* toMap);

 #endif
 #ifdef VK_AMD_memory_overallocation_behavior
 void handlemap_VkDeviceMemoryOverallocationCreateInfoAMD(
     VulkanHandleMapping* handlemap, VkDeviceMemoryOverallocationCreateInfoAMD* toMap);

 #endif
 #ifdef VK_EXT_vertex_attribute_divisor
 void handlemap_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* toMap);

 void handlemap_VkVertexInputBindingDivisorDescriptionEXT(
     VulkanHandleMapping* handlemap, VkVertexInputBindingDivisorDescriptionEXT* toMap);

 void handlemap_VkPipelineVertexInputDivisorStateCreateInfoEXT(
     VulkanHandleMapping* handlemap, VkPipelineVertexInputDivisorStateCreateInfoEXT* toMap);

 void handlemap_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* toMap);

 #endif
 #ifdef VK_GGP_frame_token
 void handlemap_VkPresentFrameTokenGGP(VulkanHandleMapping* handlemap,
                                       VkPresentFrameTokenGGP* toMap);

 #endif
 #ifdef VK_EXT_pipeline_creation_feedback
 void handlemap_VkPipelineCreationFeedbackEXT(VulkanHandleMapping* handlemap,
                                              VkPipelineCreationFeedbackEXT* toMap);

 void handlemap_VkPipelineCreationFeedbackCreateInfoEXT(
     VulkanHandleMapping* handlemap, VkPipelineCreationFeedbackCreateInfoEXT* toMap);

 #endif
 #ifdef VK_NV_shader_subgroup_partitioned
 #endif
 #ifdef VK_NV_compute_shader_derivatives
 void handlemap_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* toMap);

 #endif
 #ifdef VK_NV_mesh_shader
 void handlemap_VkPhysicalDeviceMeshShaderFeaturesNV(VulkanHandleMapping* handlemap,
                                                     VkPhysicalDeviceMeshShaderFeaturesNV* toMap);

 void handlemap_VkPhysicalDeviceMeshShaderPropertiesNV(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceMeshShaderPropertiesNV* toMap);

 void handlemap_VkDrawMeshTasksIndirectCommandNV(VulkanHandleMapping* handlemap,
                                                 VkDrawMeshTasksIndirectCommandNV* toMap);

 #endif
 #ifdef VK_NV_fragment_shader_barycentric
 void handlemap_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* toMap);

 #endif
 #ifdef VK_NV_shader_image_footprint
 void handlemap_VkPhysicalDeviceShaderImageFootprintFeaturesNV(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderImageFootprintFeaturesNV* toMap);

 #endif
 #ifdef VK_NV_scissor_exclusive
 void handlemap_VkPipelineViewportExclusiveScissorStateCreateInfoNV(
     VulkanHandleMapping* handlemap, VkPipelineViewportExclusiveScissorStateCreateInfoNV* toMap);

 void handlemap_VkPhysicalDeviceExclusiveScissorFeaturesNV(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceExclusiveScissorFeaturesNV* toMap);

 #endif
 #ifdef VK_NV_device_diagnostic_checkpoints
 void handlemap_VkQueueFamilyCheckpointPropertiesNV(VulkanHandleMapping* handlemap,
                                                    VkQueueFamilyCheckpointPropertiesNV* toMap);

 void handlemap_VkCheckpointDataNV(VulkanHandleMapping* handlemap, VkCheckpointDataNV* toMap);

 #endif
 #ifdef VK_INTEL_shader_integer_functions2
 void handlemap_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* toMap);

 #endif
 #ifdef VK_INTEL_performance_query
 void handlemap_VkPerformanceValueDataINTEL(VulkanHandleMapping* handlemap,
                                            VkPerformanceValueDataINTEL* toMap);

 void handlemap_VkPerformanceValueINTEL(VulkanHandleMapping* handlemap,
                                        VkPerformanceValueINTEL* toMap);

 void handlemap_VkInitializePerformanceApiInfoINTEL(VulkanHandleMapping* handlemap,
                                                    VkInitializePerformanceApiInfoINTEL* toMap);

 void handlemap_VkQueryPoolPerformanceQueryCreateInfoINTEL(
     VulkanHandleMapping* handlemap, VkQueryPoolPerformanceQueryCreateInfoINTEL* toMap);

 DEFINE_ALIAS_FUNCTION(handlemap_VkQueryPoolPerformanceQueryCreateInfoINTEL,
                       handlemap_VkQueryPoolCreateInfoINTEL)

 void handlemap_VkPerformanceMarkerInfoINTEL(VulkanHandleMapping* handlemap,
                                             VkPerformanceMarkerInfoINTEL* toMap);

 void handlemap_VkPerformanceStreamMarkerInfoINTEL(VulkanHandleMapping* handlemap,
                                                   VkPerformanceStreamMarkerInfoINTEL* toMap);

 void handlemap_VkPerformanceOverrideInfoINTEL(VulkanHandleMapping* handlemap,
                                               VkPerformanceOverrideInfoINTEL* toMap);

 void handlemap_VkPerformanceConfigurationAcquireInfoINTEL(
     VulkanHandleMapping* handlemap, VkPerformanceConfigurationAcquireInfoINTEL* toMap);

 #endif
 #ifdef VK_EXT_pci_bus_info
 void handlemap_VkPhysicalDevicePCIBusInfoPropertiesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDevicePCIBusInfoPropertiesEXT* toMap);

 #endif
 #ifdef VK_AMD_display_native_hdr
 void handlemap_VkDisplayNativeHdrSurfaceCapabilitiesAMD(
     VulkanHandleMapping* handlemap, VkDisplayNativeHdrSurfaceCapabilitiesAMD* toMap);

 void handlemap_VkSwapchainDisplayNativeHdrCreateInfoAMD(
     VulkanHandleMapping* handlemap, VkSwapchainDisplayNativeHdrCreateInfoAMD* toMap);

 #endif
 #ifdef VK_FUCHSIA_imagepipe_surface
 void handlemap_VkImagePipeSurfaceCreateInfoFUCHSIA(VulkanHandleMapping* handlemap,
                                                    VkImagePipeSurfaceCreateInfoFUCHSIA* toMap);

 #endif
 #ifdef VK_EXT_metal_surface
 void handlemap_VkMetalSurfaceCreateInfoEXT(VulkanHandleMapping* handlemap,
                                            VkMetalSurfaceCreateInfoEXT* toMap);

 #endif
 #ifdef VK_EXT_fragment_density_map
 void handlemap_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceFragmentDensityMapFeaturesEXT* toMap);

 void handlemap_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceFragmentDensityMapPropertiesEXT* toMap);

 void handlemap_VkRenderPassFragmentDensityMapCreateInfoEXT(
     VulkanHandleMapping* handlemap, VkRenderPassFragmentDensityMapCreateInfoEXT* toMap);

 #endif
 #ifdef VK_EXT_scalar_block_layout
 DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceScalarBlockLayoutFeatures,
                       handlemap_VkPhysicalDeviceScalarBlockLayoutFeaturesEXT)

 #endif
 #ifdef VK_GOOGLE_hlsl_functionality1
 #endif
 #ifdef VK_GOOGLE_decorate_string
 #endif
 #ifdef VK_EXT_subgroup_size_control
 void handlemap_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* toMap);

 void handlemap_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* toMap);

 void handlemap_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
     VulkanHandleMapping* handlemap, VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* toMap);

 #endif
 #ifdef VK_AMD_shader_core_properties2
 void handlemap_VkPhysicalDeviceShaderCoreProperties2AMD(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderCoreProperties2AMD* toMap);

 #endif
 #ifdef VK_AMD_device_coherent_memory
 void handlemap_VkPhysicalDeviceCoherentMemoryFeaturesAMD(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceCoherentMemoryFeaturesAMD* toMap);

 #endif
 #ifdef VK_EXT_shader_image_atomic_int64
 void handlemap_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* toMap);

 #endif
 #ifdef VK_EXT_memory_budget
 void handlemap_VkPhysicalDeviceMemoryBudgetPropertiesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceMemoryBudgetPropertiesEXT* toMap);

 #endif
 #ifdef VK_EXT_memory_priority
 void handlemap_VkPhysicalDeviceMemoryPriorityFeaturesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceMemoryPriorityFeaturesEXT* toMap);

 void handlemap_VkMemoryPriorityAllocateInfoEXT(VulkanHandleMapping* handlemap,
                                                VkMemoryPriorityAllocateInfoEXT* toMap);

 #endif
 #ifdef VK_NV_dedicated_allocation_image_aliasing
 void handlemap_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(
     VulkanHandleMapping* handlemap,
     VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* toMap);

 #endif
 #ifdef VK_EXT_buffer_device_address
 void handlemap_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* toMap);

 DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT,
                       handlemap_VkPhysicalDeviceBufferAddressFeaturesEXT)

 DEFINE_ALIAS_FUNCTION(handlemap_VkBufferDeviceAddressInfo, handlemap_VkBufferDeviceAddressInfoEXT)

 void handlemap_VkBufferDeviceAddressCreateInfoEXT(VulkanHandleMapping* handlemap,
                                                   VkBufferDeviceAddressCreateInfoEXT* toMap);

 #endif
 #ifdef VK_EXT_tooling_info
 void handlemap_VkPhysicalDeviceToolPropertiesEXT(VulkanHandleMapping* handlemap,
                                                  VkPhysicalDeviceToolPropertiesEXT* toMap);

 #endif
 #ifdef VK_EXT_separate_stencil_usage
 DEFINE_ALIAS_FUNCTION(handlemap_VkImageStencilUsageCreateInfo,
                       handlemap_VkImageStencilUsageCreateInfoEXT)

 #endif
 #ifdef VK_EXT_validation_features
 void handlemap_VkValidationFeaturesEXT(VulkanHandleMapping* handlemap,
                                        VkValidationFeaturesEXT* toMap);

 #endif
 #ifdef VK_NV_cooperative_matrix
 void handlemap_VkCooperativeMatrixPropertiesNV(VulkanHandleMapping* handlemap,
                                                VkCooperativeMatrixPropertiesNV* toMap);

 void handlemap_VkPhysicalDeviceCooperativeMatrixFeaturesNV(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceCooperativeMatrixFeaturesNV* toMap);

 void handlemap_VkPhysicalDeviceCooperativeMatrixPropertiesNV(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceCooperativeMatrixPropertiesNV* toMap);

 #endif
 #ifdef VK_NV_coverage_reduction_mode
 void handlemap_VkPhysicalDeviceCoverageReductionModeFeaturesNV(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceCoverageReductionModeFeaturesNV* toMap);

 void handlemap_VkPipelineCoverageReductionStateCreateInfoNV(
     VulkanHandleMapping* handlemap, VkPipelineCoverageReductionStateCreateInfoNV* toMap);

 void handlemap_VkFramebufferMixedSamplesCombinationNV(
     VulkanHandleMapping* handlemap, VkFramebufferMixedSamplesCombinationNV* toMap);

 #endif
 #ifdef VK_EXT_fragment_shader_interlock
 void handlemap_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* toMap);

 #endif
 #ifdef VK_EXT_ycbcr_image_arrays
 void handlemap_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* toMap);

 #endif
 #ifdef VK_EXT_provoking_vertex
 void handlemap_VkPhysicalDeviceProvokingVertexFeaturesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceProvokingVertexFeaturesEXT* toMap);

 void handlemap_VkPhysicalDeviceProvokingVertexPropertiesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceProvokingVertexPropertiesEXT* toMap);

 void handlemap_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(
     VulkanHandleMapping* handlemap,
     VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* toMap);

 #endif
 #ifdef VK_EXT_full_screen_exclusive
 void handlemap_VkSurfaceFullScreenExclusiveInfoEXT(VulkanHandleMapping* handlemap,
                                                    VkSurfaceFullScreenExclusiveInfoEXT* toMap);

 void handlemap_VkSurfaceCapabilitiesFullScreenExclusiveEXT(
     VulkanHandleMapping* handlemap, VkSurfaceCapabilitiesFullScreenExclusiveEXT* toMap);

 void handlemap_VkSurfaceFullScreenExclusiveWin32InfoEXT(
     VulkanHandleMapping* handlemap, VkSurfaceFullScreenExclusiveWin32InfoEXT* toMap);

 #endif
 #ifdef VK_EXT_headless_surface
 void handlemap_VkHeadlessSurfaceCreateInfoEXT(VulkanHandleMapping* handlemap,
                                               VkHeadlessSurfaceCreateInfoEXT* toMap);

 #endif
 #ifdef VK_EXT_line_rasterization
 void handlemap_VkPhysicalDeviceLineRasterizationFeaturesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceLineRasterizationFeaturesEXT* toMap);

 void handlemap_VkPhysicalDeviceLineRasterizationPropertiesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceLineRasterizationPropertiesEXT* toMap);

 void handlemap_VkPipelineRasterizationLineStateCreateInfoEXT(
     VulkanHandleMapping* handlemap, VkPipelineRasterizationLineStateCreateInfoEXT* toMap);

 #endif
 #ifdef VK_EXT_shader_atomic_float
 void handlemap_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* toMap);

 #endif
 #ifdef VK_EXT_host_query_reset
 DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceHostQueryResetFeatures,
                       handlemap_VkPhysicalDeviceHostQueryResetFeaturesEXT)

 #endif
 #ifdef VK_EXT_index_type_uint8
 void handlemap_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceIndexTypeUint8FeaturesEXT* toMap);

 #endif
 #ifdef VK_EXT_extended_dynamic_state
 void handlemap_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* toMap);

 #endif
 #ifdef VK_EXT_shader_atomic_float2
 void handlemap_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* toMap);

 #endif
 #ifdef VK_EXT_shader_demote_to_helper_invocation
 void handlemap_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
     VulkanHandleMapping* handlemap,
     VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* toMap);

 #endif
 #ifdef VK_NV_device_generated_commands
 void handlemap_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* toMap);

 void handlemap_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* toMap);

 void handlemap_VkGraphicsShaderGroupCreateInfoNV(VulkanHandleMapping* handlemap,
                                                  VkGraphicsShaderGroupCreateInfoNV* toMap);

 void handlemap_VkGraphicsPipelineShaderGroupsCreateInfoNV(
     VulkanHandleMapping* handlemap, VkGraphicsPipelineShaderGroupsCreateInfoNV* toMap);

 void handlemap_VkBindShaderGroupIndirectCommandNV(VulkanHandleMapping* handlemap,
                                                   VkBindShaderGroupIndirectCommandNV* toMap);

 void handlemap_VkBindIndexBufferIndirectCommandNV(VulkanHandleMapping* handlemap,
                                                   VkBindIndexBufferIndirectCommandNV* toMap);

 void handlemap_VkBindVertexBufferIndirectCommandNV(VulkanHandleMapping* handlemap,
                                                    VkBindVertexBufferIndirectCommandNV* toMap);

 void handlemap_VkSetStateFlagsIndirectCommandNV(VulkanHandleMapping* handlemap,
                                                 VkSetStateFlagsIndirectCommandNV* toMap);

 void handlemap_VkIndirectCommandsStreamNV(VulkanHandleMapping* handlemap,
                                           VkIndirectCommandsStreamNV* toMap);

 void handlemap_VkIndirectCommandsLayoutTokenNV(VulkanHandleMapping* handlemap,
                                                VkIndirectCommandsLayoutTokenNV* toMap);

 void handlemap_VkIndirectCommandsLayoutCreateInfoNV(VulkanHandleMapping* handlemap,
                                                     VkIndirectCommandsLayoutCreateInfoNV* toMap);

 void handlemap_VkGeneratedCommandsInfoNV(VulkanHandleMapping* handlemap,
                                          VkGeneratedCommandsInfoNV* toMap);

 void handlemap_VkGeneratedCommandsMemoryRequirementsInfoNV(
     VulkanHandleMapping* handlemap, VkGeneratedCommandsMemoryRequirementsInfoNV* toMap);

 #endif
 #ifdef VK_NV_inherited_viewport_scissor
 void handlemap_VkPhysicalDeviceInheritedViewportScissorFeaturesNV(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceInheritedViewportScissorFeaturesNV* toMap);

 void handlemap_VkCommandBufferInheritanceViewportScissorInfoNV(
     VulkanHandleMapping* handlemap, VkCommandBufferInheritanceViewportScissorInfoNV* toMap);

 #endif
 #ifdef VK_EXT_texel_buffer_alignment
 void handlemap_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* toMap);

 void handlemap_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* toMap);

 #endif
 #ifdef VK_QCOM_render_pass_transform
 void handlemap_VkRenderPassTransformBeginInfoQCOM(VulkanHandleMapping* handlemap,
                                                   VkRenderPassTransformBeginInfoQCOM* toMap);

 void handlemap_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(
     VulkanHandleMapping* handlemap, VkCommandBufferInheritanceRenderPassTransformInfoQCOM* toMap);

 #endif
 #ifdef VK_EXT_device_memory_report
 void handlemap_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* toMap);

 void handlemap_VkDeviceMemoryReportCallbackDataEXT(VulkanHandleMapping* handlemap,
                                                    VkDeviceMemoryReportCallbackDataEXT* toMap);

 void handlemap_VkDeviceDeviceMemoryReportCreateInfoEXT(
     VulkanHandleMapping* handlemap, VkDeviceDeviceMemoryReportCreateInfoEXT* toMap);

 #endif
 #ifdef VK_EXT_acquire_drm_display
 #endif
 #ifdef VK_EXT_robustness2
 void handlemap_VkPhysicalDeviceRobustness2FeaturesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceRobustness2FeaturesEXT* toMap);

 void handlemap_VkPhysicalDeviceRobustness2PropertiesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceRobustness2PropertiesEXT* toMap);

 #endif
 #ifdef VK_EXT_custom_border_color
 void handlemap_VkSamplerCustomBorderColorCreateInfoEXT(
     VulkanHandleMapping* handlemap, VkSamplerCustomBorderColorCreateInfoEXT* toMap);

 void handlemap_VkPhysicalDeviceCustomBorderColorPropertiesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceCustomBorderColorPropertiesEXT* toMap);

 void handlemap_VkPhysicalDeviceCustomBorderColorFeaturesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceCustomBorderColorFeaturesEXT* toMap);

 #endif
 #ifdef VK_GOOGLE_user_type
 #endif
 #ifdef VK_EXT_private_data
 void handlemap_VkPhysicalDevicePrivateDataFeaturesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDevicePrivateDataFeaturesEXT* toMap);

 void handlemap_VkDevicePrivateDataCreateInfoEXT(VulkanHandleMapping* handlemap,
                                                 VkDevicePrivateDataCreateInfoEXT* toMap);

 void handlemap_VkPrivateDataSlotCreateInfoEXT(VulkanHandleMapping* handlemap,
                                               VkPrivateDataSlotCreateInfoEXT* toMap);

 #endif
 #ifdef VK_EXT_pipeline_creation_cache_control
 void handlemap_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* toMap);

 #endif
 #ifdef VK_NV_device_diagnostics_config
 void handlemap_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceDiagnosticsConfigFeaturesNV* toMap);

 void handlemap_VkDeviceDiagnosticsConfigCreateInfoNV(VulkanHandleMapping* handlemap,
                                                      VkDeviceDiagnosticsConfigCreateInfoNV* toMap);

 #endif
 #ifdef VK_QCOM_render_pass_store_ops
 #endif
 #ifdef VK_NV_fragment_shading_rate_enums
 void handlemap_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* toMap);

 void handlemap_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* toMap);

 void handlemap_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(
     VulkanHandleMapping* handlemap, VkPipelineFragmentShadingRateEnumStateCreateInfoNV* toMap);

 #endif
 #ifdef VK_NV_ray_tracing_motion_blur
 void handlemap_VkDeviceOrHostAddressConstKHR(VulkanHandleMapping* handlemap,
                                              VkDeviceOrHostAddressConstKHR* toMap);

 void handlemap_VkAccelerationStructureGeometryMotionTrianglesDataNV(
     VulkanHandleMapping* handlemap, VkAccelerationStructureGeometryMotionTrianglesDataNV* toMap);

 void handlemap_VkAccelerationStructureMotionInfoNV(VulkanHandleMapping* handlemap,
                                                    VkAccelerationStructureMotionInfoNV* toMap);

 void handlemap_VkAccelerationStructureMatrixMotionInstanceNV(
     VulkanHandleMapping* handlemap, VkAccelerationStructureMatrixMotionInstanceNV* toMap);

 void handlemap_VkSRTDataNV(VulkanHandleMapping* handlemap, VkSRTDataNV* toMap);

 void handlemap_VkAccelerationStructureSRTMotionInstanceNV(
     VulkanHandleMapping* handlemap, VkAccelerationStructureSRTMotionInstanceNV* toMap);

 void handlemap_VkAccelerationStructureMotionInstanceDataNV(
     VulkanHandleMapping* handlemap, VkAccelerationStructureMotionInstanceDataNV* toMap);

 void handlemap_VkAccelerationStructureMotionInstanceNV(
     VulkanHandleMapping* handlemap, VkAccelerationStructureMotionInstanceNV* toMap);

 void handlemap_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* toMap);

 #endif
 #ifdef VK_EXT_ycbcr_2plane_444_formats
 void handlemap_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* toMap);

 #endif
 #ifdef VK_EXT_fragment_density_map2
 void handlemap_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* toMap);

 void handlemap_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* toMap);

 #endif
 #ifdef VK_QCOM_rotated_copy_commands
 void handlemap_VkCopyCommandTransformInfoQCOM(VulkanHandleMapping* handlemap,
                                               VkCopyCommandTransformInfoQCOM* toMap);

 #endif
 #ifdef VK_EXT_image_robustness
 void handlemap_VkPhysicalDeviceImageRobustnessFeaturesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceImageRobustnessFeaturesEXT* toMap);

 #endif
 #ifdef VK_EXT_4444_formats
 void handlemap_VkPhysicalDevice4444FormatsFeaturesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDevice4444FormatsFeaturesEXT* toMap);

 #endif
 #ifdef VK_EXT_rgba10x6_formats
 void handlemap_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* toMap);

 #endif
 #ifdef VK_NV_acquire_winrt_display
 #endif
 #ifdef VK_EXT_directfb_surface
 void handlemap_VkDirectFBSurfaceCreateInfoEXT(VulkanHandleMapping* handlemap,
                                               VkDirectFBSurfaceCreateInfoEXT* toMap);

 #endif
 #ifdef VK_VALVE_mutable_descriptor_type
 void handlemap_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE* toMap);

 void handlemap_VkMutableDescriptorTypeListVALVE(VulkanHandleMapping* handlemap,
                                                 VkMutableDescriptorTypeListVALVE* toMap);

 void handlemap_VkMutableDescriptorTypeCreateInfoVALVE(
     VulkanHandleMapping* handlemap, VkMutableDescriptorTypeCreateInfoVALVE* toMap);

 #endif
 #ifdef VK_EXT_vertex_input_dynamic_state
 void handlemap_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* toMap);

 void handlemap_VkVertexInputBindingDescription2EXT(VulkanHandleMapping* handlemap,
                                                    VkVertexInputBindingDescription2EXT* toMap);

 void handlemap_VkVertexInputAttributeDescription2EXT(VulkanHandleMapping* handlemap,
                                                      VkVertexInputAttributeDescription2EXT* toMap);

 #endif
 #ifdef VK_EXT_physical_device_drm
 void handlemap_VkPhysicalDeviceDrmPropertiesEXT(VulkanHandleMapping* handlemap,
                                                 VkPhysicalDeviceDrmPropertiesEXT* toMap);

 #endif
 #ifdef VK_EXT_primitive_topology_list_restart
 void handlemap_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* toMap);

 #endif
 #ifdef VK_FUCHSIA_external_memory
 void handlemap_VkImportMemoryZirconHandleInfoFUCHSIA(VulkanHandleMapping* handlemap,
                                                      VkImportMemoryZirconHandleInfoFUCHSIA* toMap);

 void handlemap_VkMemoryZirconHandlePropertiesFUCHSIA(VulkanHandleMapping* handlemap,
                                                      VkMemoryZirconHandlePropertiesFUCHSIA* toMap);

 void handlemap_VkMemoryGetZirconHandleInfoFUCHSIA(VulkanHandleMapping* handlemap,
                                                   VkMemoryGetZirconHandleInfoFUCHSIA* toMap);

 #endif
 #ifdef VK_FUCHSIA_external_semaphore
 void handlemap_VkImportSemaphoreZirconHandleInfoFUCHSIA(
     VulkanHandleMapping* handlemap, VkImportSemaphoreZirconHandleInfoFUCHSIA* toMap);

 void handlemap_VkSemaphoreGetZirconHandleInfoFUCHSIA(VulkanHandleMapping* handlemap,
                                                      VkSemaphoreGetZirconHandleInfoFUCHSIA* toMap);

 #endif
 #ifdef VK_FUCHSIA_buffer_collection
 void handlemap_VkBufferCollectionCreateInfoFUCHSIA(VulkanHandleMapping* handlemap,
                                                    VkBufferCollectionCreateInfoFUCHSIA* toMap);

 void handlemap_VkImportMemoryBufferCollectionFUCHSIA(VulkanHandleMapping* handlemap,
                                                      VkImportMemoryBufferCollectionFUCHSIA* toMap);

 void handlemap_VkBufferCollectionImageCreateInfoFUCHSIA(
     VulkanHandleMapping* handlemap, VkBufferCollectionImageCreateInfoFUCHSIA* toMap);

 void handlemap_VkBufferCollectionConstraintsInfoFUCHSIA(
     VulkanHandleMapping* handlemap, VkBufferCollectionConstraintsInfoFUCHSIA* toMap);

 void handlemap_VkBufferConstraintsInfoFUCHSIA(VulkanHandleMapping* handlemap,
                                               VkBufferConstraintsInfoFUCHSIA* toMap);

 void handlemap_VkBufferCollectionBufferCreateInfoFUCHSIA(
     VulkanHandleMapping* handlemap, VkBufferCollectionBufferCreateInfoFUCHSIA* toMap);

 void handlemap_VkSysmemColorSpaceFUCHSIA(VulkanHandleMapping* handlemap,
                                          VkSysmemColorSpaceFUCHSIA* toMap);

 void handlemap_VkBufferCollectionPropertiesFUCHSIA(VulkanHandleMapping* handlemap,
                                                    VkBufferCollectionPropertiesFUCHSIA* toMap);

 void handlemap_VkImageFormatConstraintsInfoFUCHSIA(VulkanHandleMapping* handlemap,
                                                    VkImageFormatConstraintsInfoFUCHSIA* toMap);

 void handlemap_VkImageConstraintsInfoFUCHSIA(VulkanHandleMapping* handlemap,
                                              VkImageConstraintsInfoFUCHSIA* toMap);

 #endif
 #ifdef VK_HUAWEI_subpass_shading
 void handlemap_VkSubpassShadingPipelineCreateInfoHUAWEI(
     VulkanHandleMapping* handlemap, VkSubpassShadingPipelineCreateInfoHUAWEI* toMap);

 void handlemap_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* toMap);

 void handlemap_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceSubpassShadingPropertiesHUAWEI* toMap);

 #endif
 #ifdef VK_HUAWEI_invocation_mask
 void handlemap_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* toMap);

 #endif
 #ifdef VK_NV_external_memory_rdma
 void handlemap_VkMemoryGetRemoteAddressInfoNV(VulkanHandleMapping* handlemap,
                                               VkMemoryGetRemoteAddressInfoNV* toMap);

 void handlemap_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* toMap);

 #endif
 #ifdef VK_EXT_extended_dynamic_state2
 void handlemap_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* toMap);

 #endif
 #ifdef VK_QNX_screen_surface
 void handlemap_VkScreenSurfaceCreateInfoQNX(VulkanHandleMapping* handlemap,
                                             VkScreenSurfaceCreateInfoQNX* toMap);

 #endif
 #ifdef VK_EXT_color_write_enable
 void handlemap_VkPhysicalDeviceColorWriteEnableFeaturesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceColorWriteEnableFeaturesEXT* toMap);

 void handlemap_VkPipelineColorWriteCreateInfoEXT(VulkanHandleMapping* handlemap,
                                                  VkPipelineColorWriteCreateInfoEXT* toMap);

 #endif
 #ifdef VK_GOOGLE_gfxstream
 void handlemap_VkImportColorBufferGOOGLE(VulkanHandleMapping* handlemap,
                                          VkImportColorBufferGOOGLE* toMap);

 void handlemap_VkImportBufferGOOGLE(VulkanHandleMapping* handlemap, VkImportBufferGOOGLE* toMap);

 void handlemap_VkCreateBlobGOOGLE(VulkanHandleMapping* handlemap, VkCreateBlobGOOGLE* toMap);

 #endif
 #ifdef VK_EXT_global_priority_query
 void handlemap_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT* toMap);

 void handlemap_VkQueueFamilyGlobalPriorityPropertiesEXT(
     VulkanHandleMapping* handlemap, VkQueueFamilyGlobalPriorityPropertiesEXT* toMap);

 #endif
 #ifdef VK_EXT_multi_draw
 void handlemap_VkPhysicalDeviceMultiDrawFeaturesEXT(VulkanHandleMapping* handlemap,
                                                     VkPhysicalDeviceMultiDrawFeaturesEXT* toMap);

 void handlemap_VkPhysicalDeviceMultiDrawPropertiesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceMultiDrawPropertiesEXT* toMap);

 void handlemap_VkMultiDrawInfoEXT(VulkanHandleMapping* handlemap, VkMultiDrawInfoEXT* toMap);

 void handlemap_VkMultiDrawIndexedInfoEXT(VulkanHandleMapping* handlemap,
                                          VkMultiDrawIndexedInfoEXT* toMap);

 #endif
 #ifdef VK_EXT_load_store_op_none
 #endif
 #ifdef VK_EXT_border_color_swizzle
 void handlemap_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* toMap);

 void handlemap_VkSamplerBorderColorComponentMappingCreateInfoEXT(
     VulkanHandleMapping* handlemap, VkSamplerBorderColorComponentMappingCreateInfoEXT* toMap);

 #endif
 #ifdef VK_EXT_pageable_device_local_memory
 void handlemap_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* toMap);

 #endif
 #ifdef VK_KHR_acceleration_structure
 void handlemap_VkDeviceOrHostAddressKHR(VulkanHandleMapping* handlemap,
                                         VkDeviceOrHostAddressKHR* toMap);

 void handlemap_VkAccelerationStructureBuildRangeInfoKHR(
     VulkanHandleMapping* handlemap, VkAccelerationStructureBuildRangeInfoKHR* toMap);

 void handlemap_VkAccelerationStructureGeometryTrianglesDataKHR(
     VulkanHandleMapping* handlemap, VkAccelerationStructureGeometryTrianglesDataKHR* toMap);

 void handlemap_VkAccelerationStructureGeometryAabbsDataKHR(
     VulkanHandleMapping* handlemap, VkAccelerationStructureGeometryAabbsDataKHR* toMap);

 void handlemap_VkAccelerationStructureGeometryInstancesDataKHR(
     VulkanHandleMapping* handlemap, VkAccelerationStructureGeometryInstancesDataKHR* toMap);

 void handlemap_VkAccelerationStructureGeometryDataKHR(
     VulkanHandleMapping* handlemap, VkAccelerationStructureGeometryDataKHR* toMap);

 void handlemap_VkAccelerationStructureGeometryKHR(VulkanHandleMapping* handlemap,
                                                   VkAccelerationStructureGeometryKHR* toMap);

 void handlemap_VkAccelerationStructureBuildGeometryInfoKHR(
     VulkanHandleMapping* handlemap, VkAccelerationStructureBuildGeometryInfoKHR* toMap);

 void handlemap_VkAccelerationStructureCreateInfoKHR(VulkanHandleMapping* handlemap,
                                                     VkAccelerationStructureCreateInfoKHR* toMap);

 void handlemap_VkWriteDescriptorSetAccelerationStructureKHR(
     VulkanHandleMapping* handlemap, VkWriteDescriptorSetAccelerationStructureKHR* toMap);

 void handlemap_VkPhysicalDeviceAccelerationStructureFeaturesKHR(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceAccelerationStructureFeaturesKHR* toMap);

 void handlemap_VkPhysicalDeviceAccelerationStructurePropertiesKHR(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceAccelerationStructurePropertiesKHR* toMap);

 void handlemap_VkAccelerationStructureDeviceAddressInfoKHR(
     VulkanHandleMapping* handlemap, VkAccelerationStructureDeviceAddressInfoKHR* toMap);

 void handlemap_VkAccelerationStructureVersionInfoKHR(VulkanHandleMapping* handlemap,
                                                      VkAccelerationStructureVersionInfoKHR* toMap);

 void handlemap_VkCopyAccelerationStructureToMemoryInfoKHR(
     VulkanHandleMapping* handlemap, VkCopyAccelerationStructureToMemoryInfoKHR* toMap);

 void handlemap_VkCopyMemoryToAccelerationStructureInfoKHR(
     VulkanHandleMapping* handlemap, VkCopyMemoryToAccelerationStructureInfoKHR* toMap);

 void handlemap_VkCopyAccelerationStructureInfoKHR(VulkanHandleMapping* handlemap,
                                                   VkCopyAccelerationStructureInfoKHR* toMap);

 void handlemap_VkAccelerationStructureBuildSizesInfoKHR(
     VulkanHandleMapping* handlemap, VkAccelerationStructureBuildSizesInfoKHR* toMap);

 #endif
 #ifdef VK_KHR_ray_tracing_pipeline
 void handlemap_VkRayTracingShaderGroupCreateInfoKHR(VulkanHandleMapping* handlemap,
                                                     VkRayTracingShaderGroupCreateInfoKHR* toMap);

 void handlemap_VkRayTracingPipelineInterfaceCreateInfoKHR(
     VulkanHandleMapping* handlemap, VkRayTracingPipelineInterfaceCreateInfoKHR* toMap);

 void handlemap_VkRayTracingPipelineCreateInfoKHR(VulkanHandleMapping* handlemap,
                                                  VkRayTracingPipelineCreateInfoKHR* toMap);

 void handlemap_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceRayTracingPipelineFeaturesKHR* toMap);

 void handlemap_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceRayTracingPipelinePropertiesKHR* toMap);

 void handlemap_VkStridedDeviceAddressRegionKHR(VulkanHandleMapping* handlemap,
                                                VkStridedDeviceAddressRegionKHR* toMap);

 void handlemap_VkTraceRaysIndirectCommandKHR(VulkanHandleMapping* handlemap,
                                              VkTraceRaysIndirectCommandKHR* toMap);

 #endif
 #ifdef VK_KHR_ray_query
 void handlemap_VkPhysicalDeviceRayQueryFeaturesKHR(VulkanHandleMapping* handlemap,
                                                    VkPhysicalDeviceRayQueryFeaturesKHR* toMap);

 #endif

 }  // namespace vk
 }  // namespace gfxstream