xref: /device/generic/goldfish-opengl/system/vulkan_enc/goldfish_vk_handlemap_guest.h

// 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 codegen/vulkan/scripts/genvk.py -registry codegen/vulkan/xml/vk.xml
// -registryGfxstream codegen/vulkan/xml/vk_gfxstream.xml cereal -o host/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_VERSION_1_3
void handlemap_VkPhysicalDeviceVulkan13Features(VulkanHandleMapping* handlemap,
                                                VkPhysicalDeviceVulkan13Features* toMap);

void handlemap_VkPhysicalDeviceVulkan13Properties(VulkanHandleMapping* handlemap,
                                                  VkPhysicalDeviceVulkan13Properties* toMap);

void handlemap_VkPipelineCreationFeedback(VulkanHandleMapping* handlemap,
                                          VkPipelineCreationFeedback* toMap);

void handlemap_VkPipelineCreationFeedbackCreateInfo(VulkanHandleMapping* handlemap,
                                                    VkPipelineCreationFeedbackCreateInfo* toMap);

void handlemap_VkPhysicalDeviceShaderTerminateInvocationFeatures(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderTerminateInvocationFeatures* toMap);

void handlemap_VkPhysicalDeviceToolProperties(VulkanHandleMapping* handlemap,
                                              VkPhysicalDeviceToolProperties* toMap);

void handlemap_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* toMap);

void handlemap_VkPhysicalDevicePrivateDataFeatures(VulkanHandleMapping* handlemap,
                                                   VkPhysicalDevicePrivateDataFeatures* toMap);

void handlemap_VkDevicePrivateDataCreateInfo(VulkanHandleMapping* handlemap,
                                             VkDevicePrivateDataCreateInfo* toMap);

void handlemap_VkPrivateDataSlotCreateInfo(VulkanHandleMapping* handlemap,
                                           VkPrivateDataSlotCreateInfo* toMap);

void handlemap_VkPhysicalDevicePipelineCreationCacheControlFeatures(
    VulkanHandleMapping* handlemap, VkPhysicalDevicePipelineCreationCacheControlFeatures* toMap);

void handlemap_VkMemoryBarrier2(VulkanHandleMapping* handlemap, VkMemoryBarrier2* toMap);

void handlemap_VkBufferMemoryBarrier2(VulkanHandleMapping* handlemap,
                                      VkBufferMemoryBarrier2* toMap);

void handlemap_VkImageMemoryBarrier2(VulkanHandleMapping* handlemap, VkImageMemoryBarrier2* toMap);

void handlemap_VkDependencyInfo(VulkanHandleMapping* handlemap, VkDependencyInfo* toMap);

void handlemap_VkSemaphoreSubmitInfo(VulkanHandleMapping* handlemap, VkSemaphoreSubmitInfo* toMap);

void handlemap_VkCommandBufferSubmitInfo(VulkanHandleMapping* handlemap,
                                         VkCommandBufferSubmitInfo* toMap);

void handlemap_VkSubmitInfo2(VulkanHandleMapping* handlemap, VkSubmitInfo2* toMap);

void handlemap_VkPhysicalDeviceSynchronization2Features(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceSynchronization2Features* toMap);

void handlemap_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* toMap);

void handlemap_VkPhysicalDeviceImageRobustnessFeatures(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceImageRobustnessFeatures* toMap);

void handlemap_VkBufferCopy2(VulkanHandleMapping* handlemap, VkBufferCopy2* toMap);

void handlemap_VkCopyBufferInfo2(VulkanHandleMapping* handlemap, VkCopyBufferInfo2* toMap);

void handlemap_VkImageCopy2(VulkanHandleMapping* handlemap, VkImageCopy2* toMap);

void handlemap_VkCopyImageInfo2(VulkanHandleMapping* handlemap, VkCopyImageInfo2* toMap);

void handlemap_VkBufferImageCopy2(VulkanHandleMapping* handlemap, VkBufferImageCopy2* toMap);

void handlemap_VkCopyBufferToImageInfo2(VulkanHandleMapping* handlemap,
                                        VkCopyBufferToImageInfo2* toMap);

void handlemap_VkCopyImageToBufferInfo2(VulkanHandleMapping* handlemap,
                                        VkCopyImageToBufferInfo2* toMap);

void handlemap_VkImageBlit2(VulkanHandleMapping* handlemap, VkImageBlit2* toMap);

void handlemap_VkBlitImageInfo2(VulkanHandleMapping* handlemap, VkBlitImageInfo2* toMap);

void handlemap_VkImageResolve2(VulkanHandleMapping* handlemap, VkImageResolve2* toMap);

void handlemap_VkResolveImageInfo2(VulkanHandleMapping* handlemap, VkResolveImageInfo2* toMap);

void handlemap_VkPhysicalDeviceSubgroupSizeControlFeatures(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceSubgroupSizeControlFeatures* toMap);

void handlemap_VkPhysicalDeviceSubgroupSizeControlProperties(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceSubgroupSizeControlProperties* toMap);

void handlemap_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(
    VulkanHandleMapping* handlemap, VkPipelineShaderStageRequiredSubgroupSizeCreateInfo* toMap);

void handlemap_VkPhysicalDeviceInlineUniformBlockFeatures(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceInlineUniformBlockFeatures* toMap);

void handlemap_VkPhysicalDeviceInlineUniformBlockProperties(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceInlineUniformBlockProperties* toMap);

void handlemap_VkWriteDescriptorSetInlineUniformBlock(
    VulkanHandleMapping* handlemap, VkWriteDescriptorSetInlineUniformBlock* toMap);

void handlemap_VkDescriptorPoolInlineUniformBlockCreateInfo(
    VulkanHandleMapping* handlemap, VkDescriptorPoolInlineUniformBlockCreateInfo* toMap);

void handlemap_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceTextureCompressionASTCHDRFeatures* toMap);

void handlemap_VkRenderingAttachmentInfo(VulkanHandleMapping* handlemap,
                                         VkRenderingAttachmentInfo* toMap);

void handlemap_VkRenderingInfo(VulkanHandleMapping* handlemap, VkRenderingInfo* toMap);

void handlemap_VkPipelineRenderingCreateInfo(VulkanHandleMapping* handlemap,
                                             VkPipelineRenderingCreateInfo* toMap);

void handlemap_VkPhysicalDeviceDynamicRenderingFeatures(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceDynamicRenderingFeatures* toMap);

void handlemap_VkCommandBufferInheritanceRenderingInfo(
    VulkanHandleMapping* handlemap, VkCommandBufferInheritanceRenderingInfo* toMap);

void handlemap_VkPhysicalDeviceShaderIntegerDotProductFeatures(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderIntegerDotProductFeatures* toMap);

void handlemap_VkPhysicalDeviceShaderIntegerDotProductProperties(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderIntegerDotProductProperties* toMap);

void handlemap_VkPhysicalDeviceTexelBufferAlignmentProperties(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceTexelBufferAlignmentProperties* toMap);

void handlemap_VkFormatProperties3(VulkanHandleMapping* handlemap, VkFormatProperties3* toMap);

void handlemap_VkPhysicalDeviceMaintenance4Features(VulkanHandleMapping* handlemap,
                                                    VkPhysicalDeviceMaintenance4Features* toMap);

void handlemap_VkPhysicalDeviceMaintenance4Properties(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceMaintenance4Properties* toMap);

void handlemap_VkDeviceBufferMemoryRequirements(VulkanHandleMapping* handlemap,
                                                VkDeviceBufferMemoryRequirements* toMap);

void handlemap_VkDeviceImageMemoryRequirements(VulkanHandleMapping* handlemap,
                                               VkDeviceImageMemoryRequirements* 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_VkQueueFamilyQueryResultStatusPropertiesKHR(
    VulkanHandleMapping* handlemap, VkQueueFamilyQueryResultStatusPropertiesKHR* toMap);

void handlemap_VkQueueFamilyVideoPropertiesKHR(VulkanHandleMapping* handlemap,
                                               VkQueueFamilyVideoPropertiesKHR* toMap);

void handlemap_VkVideoProfileInfoKHR(VulkanHandleMapping* handlemap, VkVideoProfileInfoKHR* toMap);

void handlemap_VkVideoProfileListInfoKHR(VulkanHandleMapping* handlemap,
                                         VkVideoProfileListInfoKHR* toMap);

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

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

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

void handlemap_VkVideoPictureResourceInfoKHR(VulkanHandleMapping* handlemap,
                                             VkVideoPictureResourceInfoKHR* toMap);

void handlemap_VkVideoReferenceSlotInfoKHR(VulkanHandleMapping* handlemap,
                                           VkVideoReferenceSlotInfoKHR* toMap);

void handlemap_VkVideoSessionMemoryRequirementsKHR(VulkanHandleMapping* handlemap,
                                                   VkVideoSessionMemoryRequirementsKHR* toMap);

void handlemap_VkBindVideoSessionMemoryInfoKHR(VulkanHandleMapping* handlemap,
                                               VkBindVideoSessionMemoryInfoKHR* 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_VkVideoDecodeCapabilitiesKHR(VulkanHandleMapping* handlemap,
                                            VkVideoDecodeCapabilitiesKHR* toMap);

void handlemap_VkVideoDecodeUsageInfoKHR(VulkanHandleMapping* handlemap,
                                         VkVideoDecodeUsageInfoKHR* toMap);

void handlemap_VkVideoDecodeInfoKHR(VulkanHandleMapping* handlemap, VkVideoDecodeInfoKHR* toMap);

#endif
#ifdef VK_KHR_video_decode_h264
void handlemap_VkVideoDecodeH264ProfileInfoKHR(VulkanHandleMapping* handlemap,
                                               VkVideoDecodeH264ProfileInfoKHR* toMap);

void handlemap_VkVideoDecodeH264CapabilitiesKHR(VulkanHandleMapping* handlemap,
                                                VkVideoDecodeH264CapabilitiesKHR* toMap);

void handlemap_VkVideoDecodeH264SessionParametersAddInfoKHR(
    VulkanHandleMapping* handlemap, VkVideoDecodeH264SessionParametersAddInfoKHR* toMap);

void handlemap_VkVideoDecodeH264SessionParametersCreateInfoKHR(
    VulkanHandleMapping* handlemap, VkVideoDecodeH264SessionParametersCreateInfoKHR* toMap);

void handlemap_VkVideoDecodeH264PictureInfoKHR(VulkanHandleMapping* handlemap,
                                               VkVideoDecodeH264PictureInfoKHR* toMap);

void handlemap_VkVideoDecodeH264DpbSlotInfoKHR(VulkanHandleMapping* handlemap,
                                               VkVideoDecodeH264DpbSlotInfoKHR* toMap);

#endif
#ifdef VK_KHR_dynamic_rendering
DEFINE_ALIAS_FUNCTION(handlemap_VkRenderingInfo, handlemap_VkRenderingInfoKHR)

DEFINE_ALIAS_FUNCTION(handlemap_VkRenderingAttachmentInfo, handlemap_VkRenderingAttachmentInfoKHR)

DEFINE_ALIAS_FUNCTION(handlemap_VkPipelineRenderingCreateInfo,
                      handlemap_VkPipelineRenderingCreateInfoKHR)

DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceDynamicRenderingFeatures,
                      handlemap_VkPhysicalDeviceDynamicRenderingFeaturesKHR)

DEFINE_ALIAS_FUNCTION(handlemap_VkCommandBufferInheritanceRenderingInfo,
                      handlemap_VkCommandBufferInheritanceRenderingInfoKHR)

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_video_decode_h265
void handlemap_VkVideoDecodeH265ProfileInfoKHR(VulkanHandleMapping* handlemap,
                                               VkVideoDecodeH265ProfileInfoKHR* toMap);

void handlemap_VkVideoDecodeH265CapabilitiesKHR(VulkanHandleMapping* handlemap,
                                                VkVideoDecodeH265CapabilitiesKHR* toMap);

void handlemap_VkVideoDecodeH265SessionParametersAddInfoKHR(
    VulkanHandleMapping* handlemap, VkVideoDecodeH265SessionParametersAddInfoKHR* toMap);

void handlemap_VkVideoDecodeH265SessionParametersCreateInfoKHR(
    VulkanHandleMapping* handlemap, VkVideoDecodeH265SessionParametersCreateInfoKHR* toMap);

void handlemap_VkVideoDecodeH265PictureInfoKHR(VulkanHandleMapping* handlemap,
                                               VkVideoDecodeH265PictureInfoKHR* toMap);

void handlemap_VkVideoDecodeH265DpbSlotInfoKHR(VulkanHandleMapping* handlemap,
                                               VkVideoDecodeH265DpbSlotInfoKHR* toMap);

#endif
#ifdef VK_KHR_global_priority
void handlemap_VkDeviceQueueGlobalPriorityCreateInfoKHR(
    VulkanHandleMapping* handlemap, VkDeviceQueueGlobalPriorityCreateInfoKHR* toMap);

void handlemap_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* toMap);

void handlemap_VkQueueFamilyGlobalPriorityPropertiesKHR(
    VulkanHandleMapping* handlemap, VkQueueFamilyGlobalPriorityPropertiesKHR* 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
DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceShaderTerminateInvocationFeatures,
                      handlemap_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR)

#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_map_memory2
void handlemap_VkMemoryMapInfoKHR(VulkanHandleMapping* handlemap, VkMemoryMapInfoKHR* toMap);

void handlemap_VkMemoryUnmapInfoKHR(VulkanHandleMapping* handlemap, VkMemoryUnmapInfoKHR* toMap);

#endif
#ifdef VK_KHR_shader_integer_dot_product
DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceShaderIntegerDotProductFeatures,
                      handlemap_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR)

DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceShaderIntegerDotProductProperties,
                      handlemap_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR)

#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_VkVideoEncodeCapabilitiesKHR(VulkanHandleMapping* handlemap,
                                            VkVideoEncodeCapabilitiesKHR* toMap);

void handlemap_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR(
    VulkanHandleMapping* handlemap, VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* toMap);

void handlemap_VkVideoEncodeUsageInfoKHR(VulkanHandleMapping* handlemap,
                                         VkVideoEncodeUsageInfoKHR* toMap);

void handlemap_VkVideoEncodeRateControlLayerInfoKHR(VulkanHandleMapping* handlemap,
                                                    VkVideoEncodeRateControlLayerInfoKHR* toMap);

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

#endif
#ifdef VK_KHR_synchronization2
DEFINE_ALIAS_FUNCTION(handlemap_VkMemoryBarrier2, handlemap_VkMemoryBarrier2KHR)

DEFINE_ALIAS_FUNCTION(handlemap_VkBufferMemoryBarrier2, handlemap_VkBufferMemoryBarrier2KHR)

DEFINE_ALIAS_FUNCTION(handlemap_VkImageMemoryBarrier2, handlemap_VkImageMemoryBarrier2KHR)

DEFINE_ALIAS_FUNCTION(handlemap_VkDependencyInfo, handlemap_VkDependencyInfoKHR)

DEFINE_ALIAS_FUNCTION(handlemap_VkSubmitInfo2, handlemap_VkSubmitInfo2KHR)

DEFINE_ALIAS_FUNCTION(handlemap_VkSemaphoreSubmitInfo, handlemap_VkSemaphoreSubmitInfoKHR)

DEFINE_ALIAS_FUNCTION(handlemap_VkCommandBufferSubmitInfo, handlemap_VkCommandBufferSubmitInfoKHR)

DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceSynchronization2Features,
                      handlemap_VkPhysicalDeviceSynchronization2FeaturesKHR)

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

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

#endif
#ifdef VK_KHR_fragment_shader_barycentric
void handlemap_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* toMap);

void handlemap_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* 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
DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures,
                      handlemap_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR)

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

#endif
#ifdef VK_KHR_copy_commands2
DEFINE_ALIAS_FUNCTION(handlemap_VkCopyBufferInfo2, handlemap_VkCopyBufferInfo2KHR)

DEFINE_ALIAS_FUNCTION(handlemap_VkCopyImageInfo2, handlemap_VkCopyImageInfo2KHR)

DEFINE_ALIAS_FUNCTION(handlemap_VkCopyBufferToImageInfo2, handlemap_VkCopyBufferToImageInfo2KHR)

DEFINE_ALIAS_FUNCTION(handlemap_VkCopyImageToBufferInfo2, handlemap_VkCopyImageToBufferInfo2KHR)

DEFINE_ALIAS_FUNCTION(handlemap_VkBlitImageInfo2, handlemap_VkBlitImageInfo2KHR)

DEFINE_ALIAS_FUNCTION(handlemap_VkResolveImageInfo2, handlemap_VkResolveImageInfo2KHR)

DEFINE_ALIAS_FUNCTION(handlemap_VkBufferCopy2, handlemap_VkBufferCopy2KHR)

DEFINE_ALIAS_FUNCTION(handlemap_VkImageCopy2, handlemap_VkImageCopy2KHR)

DEFINE_ALIAS_FUNCTION(handlemap_VkImageBlit2, handlemap_VkImageBlit2KHR)

DEFINE_ALIAS_FUNCTION(handlemap_VkBufferImageCopy2, handlemap_VkBufferImageCopy2KHR)

DEFINE_ALIAS_FUNCTION(handlemap_VkImageResolve2, handlemap_VkImageResolve2KHR)

#endif
#ifdef VK_KHR_format_feature_flags2
DEFINE_ALIAS_FUNCTION(handlemap_VkFormatProperties3, handlemap_VkFormatProperties3KHR)

#endif
#ifdef VK_KHR_ray_tracing_maintenance1
void handlemap_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* toMap);

void handlemap_VkTraceRaysIndirectCommand2KHR(VulkanHandleMapping* handlemap,
                                              VkTraceRaysIndirectCommand2KHR* toMap);

#endif
#ifdef VK_KHR_portability_enumeration
#endif
#ifdef VK_KHR_maintenance4
DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceMaintenance4Features,
                      handlemap_VkPhysicalDeviceMaintenance4FeaturesKHR)

DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceMaintenance4Properties,
                      handlemap_VkPhysicalDeviceMaintenance4PropertiesKHR)

DEFINE_ALIAS_FUNCTION(handlemap_VkDeviceBufferMemoryRequirements,
                      handlemap_VkDeviceBufferMemoryRequirementsKHR)

DEFINE_ALIAS_FUNCTION(handlemap_VkDeviceImageMemoryRequirements,
                      handlemap_VkDeviceImageMemoryRequirementsKHR)

#endif
#ifdef VK_KHR_ray_tracing_position_fetch
void handlemap_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* toMap);

#endif
#ifdef VK_ANDROID_native_buffer
void handlemap_VkNativeBufferUsage2ANDROID(VulkanHandleMapping* handlemap,
                                           VkNativeBufferUsage2ANDROID* toMap);

void handlemap_VkNativeBufferANDROID(VulkanHandleMapping* handlemap, VkNativeBufferANDROID* toMap);

void handlemap_VkSwapchainImageCreateInfoANDROID(VulkanHandleMapping* handlemap,
                                                 VkSwapchainImageCreateInfoANDROID* toMap);

void handlemap_VkPhysicalDevicePresentationPropertiesANDROID(
    VulkanHandleMapping* handlemap, VkPhysicalDevicePresentationPropertiesANDROID* 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_VkVideoEncodeH264SessionParametersAddInfoEXT(
    VulkanHandleMapping* handlemap, VkVideoEncodeH264SessionParametersAddInfoEXT* toMap);

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

void handlemap_VkVideoEncodeH264NaluSliceInfoEXT(VulkanHandleMapping* handlemap,
                                                 VkVideoEncodeH264NaluSliceInfoEXT* toMap);

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

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

void handlemap_VkVideoEncodeH264ProfileInfoEXT(VulkanHandleMapping* handlemap,
                                               VkVideoEncodeH264ProfileInfoEXT* toMap);

void handlemap_VkVideoEncodeH264RateControlInfoEXT(VulkanHandleMapping* handlemap,
                                                   VkVideoEncodeH264RateControlInfoEXT* toMap);

void handlemap_VkVideoEncodeH264QpEXT(VulkanHandleMapping* handlemap,
                                      VkVideoEncodeH264QpEXT* toMap);

void handlemap_VkVideoEncodeH264FrameSizeEXT(VulkanHandleMapping* handlemap,
                                             VkVideoEncodeH264FrameSizeEXT* toMap);

void handlemap_VkVideoEncodeH264RateControlLayerInfoEXT(
    VulkanHandleMapping* handlemap, VkVideoEncodeH264RateControlLayerInfoEXT* toMap);

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

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

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

void handlemap_VkVideoEncodeH265NaluSliceSegmentInfoEXT(
    VulkanHandleMapping* handlemap, VkVideoEncodeH265NaluSliceSegmentInfoEXT* toMap);

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

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

void handlemap_VkVideoEncodeH265ProfileInfoEXT(VulkanHandleMapping* handlemap,
                                               VkVideoEncodeH265ProfileInfoEXT* toMap);

void handlemap_VkVideoEncodeH265RateControlInfoEXT(VulkanHandleMapping* handlemap,
                                                   VkVideoEncodeH265RateControlInfoEXT* toMap);

void handlemap_VkVideoEncodeH265QpEXT(VulkanHandleMapping* handlemap,
                                      VkVideoEncodeH265QpEXT* toMap);

void handlemap_VkVideoEncodeH265FrameSizeEXT(VulkanHandleMapping* handlemap,
                                             VkVideoEncodeH265FrameSizeEXT* toMap);

void handlemap_VkVideoEncodeH265RateControlLayerInfoEXT(
    VulkanHandleMapping* handlemap, VkVideoEncodeH265RateControlLayerInfoEXT* 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
DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceTextureCompressionASTCHDRFeatures,
                      handlemap_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT)

#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_pipeline_robustness
void handlemap_VkPhysicalDevicePipelineRobustnessFeaturesEXT(
    VulkanHandleMapping* handlemap, VkPhysicalDevicePipelineRobustnessFeaturesEXT* toMap);

void handlemap_VkPhysicalDevicePipelineRobustnessPropertiesEXT(
    VulkanHandleMapping* handlemap, VkPhysicalDevicePipelineRobustnessPropertiesEXT* toMap);

void handlemap_VkPipelineRobustnessCreateInfoEXT(VulkanHandleMapping* handlemap,
                                                 VkPipelineRobustnessCreateInfoEXT* 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_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
DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceInlineUniformBlockFeatures,
                      handlemap_VkPhysicalDeviceInlineUniformBlockFeaturesEXT)

DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceInlineUniformBlockProperties,
                      handlemap_VkPhysicalDeviceInlineUniformBlockPropertiesEXT)

DEFINE_ALIAS_FUNCTION(handlemap_VkWriteDescriptorSetInlineUniformBlock,
                      handlemap_VkWriteDescriptorSetInlineUniformBlockEXT)

DEFINE_ALIAS_FUNCTION(handlemap_VkDescriptorPoolInlineUniformBlockCreateInfo,
                      handlemap_VkDescriptorPoolInlineUniformBlockCreateInfoEXT)

#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
DEFINE_ALIAS_FUNCTION(handlemap_VkDeviceQueueGlobalPriorityCreateInfoKHR,
                      handlemap_VkDeviceQueueGlobalPriorityCreateInfoEXT)

#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_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
DEFINE_ALIAS_FUNCTION(handlemap_VkPipelineCreationFeedbackCreateInfo,
                      handlemap_VkPipelineCreationFeedbackCreateInfoEXT)

DEFINE_ALIAS_FUNCTION(handlemap_VkPipelineCreationFeedback, handlemap_VkPipelineCreationFeedbackEXT)

#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
DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR,
                      handlemap_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV)

#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
DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceSubgroupSizeControlFeatures,
                      handlemap_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT)

DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceSubgroupSizeControlProperties,
                      handlemap_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT)

DEFINE_ALIAS_FUNCTION(handlemap_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo,
                      handlemap_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT)

#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
DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceToolProperties,
                      handlemap_VkPhysicalDeviceToolPropertiesEXT)

#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_surface_maintenance1
void handlemap_VkSurfacePresentModeEXT(VulkanHandleMapping* handlemap,
                                       VkSurfacePresentModeEXT* toMap);

void handlemap_VkSurfacePresentScalingCapabilitiesEXT(
    VulkanHandleMapping* handlemap, VkSurfacePresentScalingCapabilitiesEXT* toMap);

void handlemap_VkSurfacePresentModeCompatibilityEXT(VulkanHandleMapping* handlemap,
                                                    VkSurfacePresentModeCompatibilityEXT* toMap);

#endif
#ifdef VK_EXT_swapchain_maintenance1
void handlemap_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* toMap);

void handlemap_VkSwapchainPresentFenceInfoEXT(VulkanHandleMapping* handlemap,
                                              VkSwapchainPresentFenceInfoEXT* toMap);

void handlemap_VkSwapchainPresentModesCreateInfoEXT(VulkanHandleMapping* handlemap,
                                                    VkSwapchainPresentModesCreateInfoEXT* toMap);

void handlemap_VkSwapchainPresentModeInfoEXT(VulkanHandleMapping* handlemap,
                                             VkSwapchainPresentModeInfoEXT* toMap);

void handlemap_VkSwapchainPresentScalingCreateInfoEXT(
    VulkanHandleMapping* handlemap, VkSwapchainPresentScalingCreateInfoEXT* toMap);

void handlemap_VkReleaseSwapchainImagesInfoEXT(VulkanHandleMapping* handlemap,
                                               VkReleaseSwapchainImagesInfoEXT* toMap);

#endif
#ifdef VK_EXT_shader_demote_to_helper_invocation
DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures,
                      handlemap_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT)

#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);

DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceTexelBufferAlignmentProperties,
                      handlemap_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT)

#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_NV_present_barrier
void handlemap_VkPhysicalDevicePresentBarrierFeaturesNV(
    VulkanHandleMapping* handlemap, VkPhysicalDevicePresentBarrierFeaturesNV* toMap);

void handlemap_VkSurfaceCapabilitiesPresentBarrierNV(VulkanHandleMapping* handlemap,
                                                     VkSurfaceCapabilitiesPresentBarrierNV* toMap);

void handlemap_VkSwapchainPresentBarrierCreateInfoNV(VulkanHandleMapping* handlemap,
                                                     VkSwapchainPresentBarrierCreateInfoNV* toMap);

#endif
#ifdef VK_EXT_private_data
DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDevicePrivateDataFeatures,
                      handlemap_VkPhysicalDevicePrivateDataFeaturesEXT)

DEFINE_ALIAS_FUNCTION(handlemap_VkDevicePrivateDataCreateInfo,
                      handlemap_VkDevicePrivateDataCreateInfoEXT)

DEFINE_ALIAS_FUNCTION(handlemap_VkPrivateDataSlotCreateInfo,
                      handlemap_VkPrivateDataSlotCreateInfoEXT)

#endif
#ifdef VK_EXT_pipeline_creation_cache_control
DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDevicePipelineCreationCacheControlFeatures,
                      handlemap_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT)

#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_low_latency
void handlemap_VkQueryLowLatencySupportNV(VulkanHandleMapping* handlemap,
                                          VkQueryLowLatencySupportNV* toMap);

#endif
#ifdef VK_EXT_metal_objects
void handlemap_VkExportMetalObjectCreateInfoEXT(VulkanHandleMapping* handlemap,
                                                VkExportMetalObjectCreateInfoEXT* toMap);

void handlemap_VkExportMetalObjectsInfoEXT(VulkanHandleMapping* handlemap,
                                           VkExportMetalObjectsInfoEXT* toMap);

void handlemap_VkExportMetalDeviceInfoEXT(VulkanHandleMapping* handlemap,
                                          VkExportMetalDeviceInfoEXT* toMap);

void handlemap_VkExportMetalCommandQueueInfoEXT(VulkanHandleMapping* handlemap,
                                                VkExportMetalCommandQueueInfoEXT* toMap);

void handlemap_VkExportMetalBufferInfoEXT(VulkanHandleMapping* handlemap,
                                          VkExportMetalBufferInfoEXT* toMap);

void handlemap_VkImportMetalBufferInfoEXT(VulkanHandleMapping* handlemap,
                                          VkImportMetalBufferInfoEXT* toMap);

void handlemap_VkExportMetalTextureInfoEXT(VulkanHandleMapping* handlemap,
                                           VkExportMetalTextureInfoEXT* toMap);

void handlemap_VkImportMetalTextureInfoEXT(VulkanHandleMapping* handlemap,
                                           VkImportMetalTextureInfoEXT* toMap);

void handlemap_VkExportMetalIOSurfaceInfoEXT(VulkanHandleMapping* handlemap,
                                             VkExportMetalIOSurfaceInfoEXT* toMap);

void handlemap_VkImportMetalIOSurfaceInfoEXT(VulkanHandleMapping* handlemap,
                                             VkImportMetalIOSurfaceInfoEXT* toMap);

void handlemap_VkExportMetalSharedEventInfoEXT(VulkanHandleMapping* handlemap,
                                               VkExportMetalSharedEventInfoEXT* toMap);

void handlemap_VkImportMetalSharedEventInfoEXT(VulkanHandleMapping* handlemap,
                                               VkImportMetalSharedEventInfoEXT* toMap);

#endif
#ifdef VK_EXT_descriptor_buffer
void handlemap_VkPhysicalDeviceDescriptorBufferPropertiesEXT(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceDescriptorBufferPropertiesEXT* toMap);

void handlemap_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT* toMap);

void handlemap_VkPhysicalDeviceDescriptorBufferFeaturesEXT(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceDescriptorBufferFeaturesEXT* toMap);

void handlemap_VkDescriptorAddressInfoEXT(VulkanHandleMapping* handlemap,
                                          VkDescriptorAddressInfoEXT* toMap);

void handlemap_VkDescriptorBufferBindingInfoEXT(VulkanHandleMapping* handlemap,
                                                VkDescriptorBufferBindingInfoEXT* toMap);

void handlemap_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT(
    VulkanHandleMapping* handlemap, VkDescriptorBufferBindingPushDescriptorBufferHandleEXT* toMap);

void handlemap_VkDescriptorDataEXT(VulkanHandleMapping* handlemap, VkDescriptorDataEXT* toMap);

void handlemap_VkDescriptorGetInfoEXT(VulkanHandleMapping* handlemap,
                                      VkDescriptorGetInfoEXT* toMap);

void handlemap_VkBufferCaptureDescriptorDataInfoEXT(VulkanHandleMapping* handlemap,
                                                    VkBufferCaptureDescriptorDataInfoEXT* toMap);

void handlemap_VkImageCaptureDescriptorDataInfoEXT(VulkanHandleMapping* handlemap,
                                                   VkImageCaptureDescriptorDataInfoEXT* toMap);

void handlemap_VkImageViewCaptureDescriptorDataInfoEXT(
    VulkanHandleMapping* handlemap, VkImageViewCaptureDescriptorDataInfoEXT* toMap);

void handlemap_VkSamplerCaptureDescriptorDataInfoEXT(VulkanHandleMapping* handlemap,
                                                     VkSamplerCaptureDescriptorDataInfoEXT* toMap);

void handlemap_VkOpaqueCaptureDescriptorDataCreateInfoEXT(
    VulkanHandleMapping* handlemap, VkOpaqueCaptureDescriptorDataCreateInfoEXT* toMap);

void handlemap_VkAccelerationStructureCaptureDescriptorDataInfoEXT(
    VulkanHandleMapping* handlemap, VkAccelerationStructureCaptureDescriptorDataInfoEXT* toMap);

#endif
#ifdef VK_EXT_graphics_pipeline_library
void handlemap_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* toMap);

void handlemap_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* toMap);

void handlemap_VkGraphicsPipelineLibraryCreateInfoEXT(
    VulkanHandleMapping* handlemap, VkGraphicsPipelineLibraryCreateInfoEXT* toMap);

#endif
#ifdef VK_AMD_shader_early_and_late_fragment_tests
void handlemap_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD(
    VulkanHandleMapping* handlemap,
    VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* toMap);

#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
DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceImageRobustnessFeatures,
                      handlemap_VkPhysicalDeviceImageRobustnessFeaturesEXT)

#endif
#ifdef VK_EXT_image_compression_control
void handlemap_VkPhysicalDeviceImageCompressionControlFeaturesEXT(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceImageCompressionControlFeaturesEXT* toMap);

void handlemap_VkImageCompressionControlEXT(VulkanHandleMapping* handlemap,
                                            VkImageCompressionControlEXT* toMap);

void handlemap_VkSubresourceLayout2EXT(VulkanHandleMapping* handlemap,
                                       VkSubresourceLayout2EXT* toMap);

void handlemap_VkImageSubresource2EXT(VulkanHandleMapping* handlemap,
                                      VkImageSubresource2EXT* toMap);

void handlemap_VkImageCompressionPropertiesEXT(VulkanHandleMapping* handlemap,
                                               VkImageCompressionPropertiesEXT* toMap);

#endif
#ifdef VK_EXT_attachment_feedback_loop_layout
void handlemap_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* toMap);

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

#endif
#ifdef VK_EXT_device_fault
void handlemap_VkPhysicalDeviceFaultFeaturesEXT(VulkanHandleMapping* handlemap,
                                                VkPhysicalDeviceFaultFeaturesEXT* toMap);

void handlemap_VkDeviceFaultCountsEXT(VulkanHandleMapping* handlemap,
                                      VkDeviceFaultCountsEXT* toMap);

void handlemap_VkDeviceFaultAddressInfoEXT(VulkanHandleMapping* handlemap,
                                           VkDeviceFaultAddressInfoEXT* toMap);

void handlemap_VkDeviceFaultVendorInfoEXT(VulkanHandleMapping* handlemap,
                                          VkDeviceFaultVendorInfoEXT* toMap);

void handlemap_VkDeviceFaultInfoEXT(VulkanHandleMapping* handlemap, VkDeviceFaultInfoEXT* toMap);

void handlemap_VkDeviceFaultVendorBinaryHeaderVersionOneEXT(
    VulkanHandleMapping* handlemap, VkDeviceFaultVendorBinaryHeaderVersionOneEXT* toMap);

#endif
#ifdef VK_ARM_rasterization_order_attachment_access
void handlemap_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(
    VulkanHandleMapping* handlemap,
    VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* toMap);

DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT,
                      handlemap_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM)

#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_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* toMap);

DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT,
                      handlemap_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE)

void handlemap_VkMutableDescriptorTypeListEXT(VulkanHandleMapping* handlemap,
                                              VkMutableDescriptorTypeListEXT* toMap);

DEFINE_ALIAS_FUNCTION(handlemap_VkMutableDescriptorTypeListEXT,
                      handlemap_VkMutableDescriptorTypeListVALVE)

void handlemap_VkMutableDescriptorTypeCreateInfoEXT(VulkanHandleMapping* handlemap,
                                                    VkMutableDescriptorTypeCreateInfoEXT* toMap);

DEFINE_ALIAS_FUNCTION(handlemap_VkMutableDescriptorTypeCreateInfoEXT,
                      handlemap_VkMutableDescriptorTypeCreateInfoVALVE)

#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_device_address_binding_report
void handlemap_VkPhysicalDeviceAddressBindingReportFeaturesEXT(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceAddressBindingReportFeaturesEXT* toMap);

void handlemap_VkDeviceAddressBindingCallbackDataEXT(VulkanHandleMapping* handlemap,
                                                     VkDeviceAddressBindingCallbackDataEXT* toMap);

#endif
#ifdef VK_EXT_depth_clip_control
void handlemap_VkPhysicalDeviceDepthClipControlFeaturesEXT(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceDepthClipControlFeaturesEXT* toMap);

void handlemap_VkPipelineViewportDepthClipControlCreateInfoEXT(
    VulkanHandleMapping* handlemap, VkPipelineViewportDepthClipControlCreateInfoEXT* 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_pipeline_properties
DEFINE_ALIAS_FUNCTION(handlemap_VkPipelineInfoKHR, handlemap_VkPipelineInfoEXT)

void handlemap_VkPipelinePropertiesIdentifierEXT(VulkanHandleMapping* handlemap,
                                                 VkPipelinePropertiesIdentifierEXT* toMap);

void handlemap_VkPhysicalDevicePipelinePropertiesFeaturesEXT(
    VulkanHandleMapping* handlemap, VkPhysicalDevicePipelinePropertiesFeaturesEXT* toMap);

#endif
#ifdef VK_EXT_multisampled_render_to_single_sampled
void handlemap_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(
    VulkanHandleMapping* handlemap,
    VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* toMap);

void handlemap_VkSubpassResolvePerformanceQueryEXT(VulkanHandleMapping* handlemap,
                                                   VkSubpassResolvePerformanceQueryEXT* toMap);

void handlemap_VkMultisampledRenderToSingleSampledInfoEXT(
    VulkanHandleMapping* handlemap, VkMultisampledRenderToSingleSampledInfoEXT* 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_EXT_primitives_generated_query
void handlemap_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(
    VulkanHandleMapping* handlemap, VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* 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
DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR,
                      handlemap_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT)

DEFINE_ALIAS_FUNCTION(handlemap_VkQueueFamilyGlobalPriorityPropertiesKHR,
                      handlemap_VkQueueFamilyGlobalPriorityPropertiesEXT)

#endif
#ifdef VK_EXT_image_view_min_lod
void handlemap_VkPhysicalDeviceImageViewMinLodFeaturesEXT(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceImageViewMinLodFeaturesEXT* toMap);

void handlemap_VkImageViewMinLodCreateInfoEXT(VulkanHandleMapping* handlemap,
                                              VkImageViewMinLodCreateInfoEXT* 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_image_2d_view_of_3d
void handlemap_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* toMap);

#endif
#ifdef VK_EXT_shader_tile_image
void handlemap_VkPhysicalDeviceShaderTileImageFeaturesEXT(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderTileImageFeaturesEXT* toMap);

void handlemap_VkPhysicalDeviceShaderTileImagePropertiesEXT(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderTileImagePropertiesEXT* toMap);

#endif
#ifdef VK_EXT_opacity_micromap
void handlemap_VkMicromapUsageEXT(VulkanHandleMapping* handlemap, VkMicromapUsageEXT* toMap);

void handlemap_VkDeviceOrHostAddressKHR(VulkanHandleMapping* handlemap,
                                        VkDeviceOrHostAddressKHR* toMap);

void handlemap_VkMicromapBuildInfoEXT(VulkanHandleMapping* handlemap,
                                      VkMicromapBuildInfoEXT* toMap);

void handlemap_VkMicromapCreateInfoEXT(VulkanHandleMapping* handlemap,
                                       VkMicromapCreateInfoEXT* toMap);

void handlemap_VkPhysicalDeviceOpacityMicromapFeaturesEXT(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceOpacityMicromapFeaturesEXT* toMap);

void handlemap_VkPhysicalDeviceOpacityMicromapPropertiesEXT(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceOpacityMicromapPropertiesEXT* toMap);

void handlemap_VkMicromapVersionInfoEXT(VulkanHandleMapping* handlemap,
                                        VkMicromapVersionInfoEXT* toMap);

void handlemap_VkCopyMicromapToMemoryInfoEXT(VulkanHandleMapping* handlemap,
                                             VkCopyMicromapToMemoryInfoEXT* toMap);

void handlemap_VkCopyMemoryToMicromapInfoEXT(VulkanHandleMapping* handlemap,
                                             VkCopyMemoryToMicromapInfoEXT* toMap);

void handlemap_VkCopyMicromapInfoEXT(VulkanHandleMapping* handlemap, VkCopyMicromapInfoEXT* toMap);

void handlemap_VkMicromapBuildSizesInfoEXT(VulkanHandleMapping* handlemap,
                                           VkMicromapBuildSizesInfoEXT* toMap);

void handlemap_VkAccelerationStructureTrianglesOpacityMicromapEXT(
    VulkanHandleMapping* handlemap, VkAccelerationStructureTrianglesOpacityMicromapEXT* toMap);

void handlemap_VkMicromapTriangleEXT(VulkanHandleMapping* handlemap, VkMicromapTriangleEXT* toMap);

#endif
#ifdef VK_NV_displacement_micromap
void handlemap_VkPhysicalDeviceDisplacementMicromapFeaturesNV(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceDisplacementMicromapFeaturesNV* toMap);

void handlemap_VkPhysicalDeviceDisplacementMicromapPropertiesNV(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceDisplacementMicromapPropertiesNV* toMap);

void handlemap_VkAccelerationStructureTrianglesDisplacementMicromapNV(
    VulkanHandleMapping* handlemap, VkAccelerationStructureTrianglesDisplacementMicromapNV* toMap);

#endif
#ifdef VK_EXT_load_store_op_none
#endif
#ifdef VK_HUAWEI_cluster_culling_shader
void handlemap_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* toMap);

void handlemap_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI* toMap);

#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_ARM_shader_core_properties
void handlemap_VkPhysicalDeviceShaderCorePropertiesARM(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderCorePropertiesARM* toMap);

#endif
#ifdef VK_EXT_image_sliced_view_of_3d
void handlemap_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* toMap);

void handlemap_VkImageViewSlicedCreateInfoEXT(VulkanHandleMapping* handlemap,
                                              VkImageViewSlicedCreateInfoEXT* toMap);

#endif
#ifdef VK_VALVE_descriptor_set_host_mapping
void handlemap_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* toMap);

void handlemap_VkDescriptorSetBindingReferenceVALVE(VulkanHandleMapping* handlemap,
                                                    VkDescriptorSetBindingReferenceVALVE* toMap);

void handlemap_VkDescriptorSetLayoutHostMappingInfoVALVE(
    VulkanHandleMapping* handlemap, VkDescriptorSetLayoutHostMappingInfoVALVE* toMap);

#endif
#ifdef VK_EXT_depth_clamp_zero_one
void handlemap_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* toMap);

#endif
#ifdef VK_EXT_non_seamless_cube_map
void handlemap_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* toMap);

#endif
#ifdef VK_QCOM_fragment_density_map_offset
void handlemap_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* toMap);

void handlemap_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* toMap);

void handlemap_VkSubpassFragmentDensityMapOffsetEndInfoQCOM(
    VulkanHandleMapping* handlemap, VkSubpassFragmentDensityMapOffsetEndInfoQCOM* toMap);

#endif
#ifdef VK_NV_copy_memory_indirect
void handlemap_VkCopyMemoryIndirectCommandNV(VulkanHandleMapping* handlemap,
                                             VkCopyMemoryIndirectCommandNV* toMap);

void handlemap_VkCopyMemoryToImageIndirectCommandNV(VulkanHandleMapping* handlemap,
                                                    VkCopyMemoryToImageIndirectCommandNV* toMap);

void handlemap_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceCopyMemoryIndirectFeaturesNV* toMap);

void handlemap_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceCopyMemoryIndirectPropertiesNV* toMap);

#endif
#ifdef VK_NV_memory_decompression
void handlemap_VkDecompressMemoryRegionNV(VulkanHandleMapping* handlemap,
                                          VkDecompressMemoryRegionNV* toMap);

void handlemap_VkPhysicalDeviceMemoryDecompressionFeaturesNV(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceMemoryDecompressionFeaturesNV* toMap);

void handlemap_VkPhysicalDeviceMemoryDecompressionPropertiesNV(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceMemoryDecompressionPropertiesNV* toMap);

#endif
#ifdef VK_NV_linear_color_attachment
void handlemap_VkPhysicalDeviceLinearColorAttachmentFeaturesNV(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceLinearColorAttachmentFeaturesNV* toMap);

#endif
#ifdef VK_GOOGLE_surfaceless_query
#endif
#ifdef VK_EXT_image_compression_control_swapchain
void handlemap_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(
    VulkanHandleMapping* handlemap,
    VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* toMap);

#endif
#ifdef VK_QCOM_image_processing
void handlemap_VkImageViewSampleWeightCreateInfoQCOM(VulkanHandleMapping* handlemap,
                                                     VkImageViewSampleWeightCreateInfoQCOM* toMap);

void handlemap_VkPhysicalDeviceImageProcessingFeaturesQCOM(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceImageProcessingFeaturesQCOM* toMap);

void handlemap_VkPhysicalDeviceImageProcessingPropertiesQCOM(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceImageProcessingPropertiesQCOM* toMap);

#endif
#ifdef VK_EXT_extended_dynamic_state3
void handlemap_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* toMap);

void handlemap_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceExtendedDynamicState3PropertiesEXT* toMap);

void handlemap_VkColorBlendEquationEXT(VulkanHandleMapping* handlemap,
                                       VkColorBlendEquationEXT* toMap);

void handlemap_VkColorBlendAdvancedEXT(VulkanHandleMapping* handlemap,
                                       VkColorBlendAdvancedEXT* toMap);

#endif
#ifdef VK_EXT_subpass_merge_feedback
void handlemap_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* toMap);

void handlemap_VkRenderPassCreationControlEXT(VulkanHandleMapping* handlemap,
                                              VkRenderPassCreationControlEXT* toMap);

void handlemap_VkRenderPassCreationFeedbackInfoEXT(VulkanHandleMapping* handlemap,
                                                   VkRenderPassCreationFeedbackInfoEXT* toMap);

void handlemap_VkRenderPassCreationFeedbackCreateInfoEXT(
    VulkanHandleMapping* handlemap, VkRenderPassCreationFeedbackCreateInfoEXT* toMap);

void handlemap_VkRenderPassSubpassFeedbackInfoEXT(VulkanHandleMapping* handlemap,
                                                  VkRenderPassSubpassFeedbackInfoEXT* toMap);

void handlemap_VkRenderPassSubpassFeedbackCreateInfoEXT(
    VulkanHandleMapping* handlemap, VkRenderPassSubpassFeedbackCreateInfoEXT* toMap);

#endif
#ifdef VK_LUNARG_direct_driver_loading
void handlemap_VkDirectDriverLoadingInfoLUNARG(VulkanHandleMapping* handlemap,
                                               VkDirectDriverLoadingInfoLUNARG* toMap);

void handlemap_VkDirectDriverLoadingListLUNARG(VulkanHandleMapping* handlemap,
                                               VkDirectDriverLoadingListLUNARG* toMap);

#endif
#ifdef VK_EXT_shader_module_identifier
void handlemap_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* toMap);

void handlemap_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT* toMap);

void handlemap_VkPipelineShaderStageModuleIdentifierCreateInfoEXT(
    VulkanHandleMapping* handlemap, VkPipelineShaderStageModuleIdentifierCreateInfoEXT* toMap);

void handlemap_VkShaderModuleIdentifierEXT(VulkanHandleMapping* handlemap,
                                           VkShaderModuleIdentifierEXT* toMap);

#endif
#ifdef VK_EXT_rasterization_order_attachment_access
#endif
#ifdef VK_NV_optical_flow
void handlemap_VkPhysicalDeviceOpticalFlowFeaturesNV(VulkanHandleMapping* handlemap,
                                                     VkPhysicalDeviceOpticalFlowFeaturesNV* toMap);

void handlemap_VkPhysicalDeviceOpticalFlowPropertiesNV(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceOpticalFlowPropertiesNV* toMap);

void handlemap_VkOpticalFlowImageFormatInfoNV(VulkanHandleMapping* handlemap,
                                              VkOpticalFlowImageFormatInfoNV* toMap);

void handlemap_VkOpticalFlowImageFormatPropertiesNV(VulkanHandleMapping* handlemap,
                                                    VkOpticalFlowImageFormatPropertiesNV* toMap);

void handlemap_VkOpticalFlowSessionCreateInfoNV(VulkanHandleMapping* handlemap,
                                                VkOpticalFlowSessionCreateInfoNV* toMap);

void handlemap_VkOpticalFlowSessionCreatePrivateDataInfoNV(
    VulkanHandleMapping* handlemap, VkOpticalFlowSessionCreatePrivateDataInfoNV* toMap);

void handlemap_VkOpticalFlowExecuteInfoNV(VulkanHandleMapping* handlemap,
                                          VkOpticalFlowExecuteInfoNV* toMap);

#endif
#ifdef VK_EXT_legacy_dithering
void handlemap_VkPhysicalDeviceLegacyDitheringFeaturesEXT(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceLegacyDitheringFeaturesEXT* toMap);

#endif
#ifdef VK_EXT_pipeline_protected_access
void handlemap_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(
    VulkanHandleMapping* handlemap, VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* toMap);

#endif
#ifdef VK_EXT_shader_object
void handlemap_VkPhysicalDeviceShaderObjectFeaturesEXT(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderObjectFeaturesEXT* toMap);

void handlemap_VkPhysicalDeviceShaderObjectPropertiesEXT(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderObjectPropertiesEXT* toMap);

void handlemap_VkShaderCreateInfoEXT(VulkanHandleMapping* handlemap, VkShaderCreateInfoEXT* toMap);

DEFINE_ALIAS_FUNCTION(handlemap_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo,
                      handlemap_VkShaderRequiredSubgroupSizeCreateInfoEXT)

#endif
#ifdef VK_QCOM_tile_properties
void handlemap_VkPhysicalDeviceTilePropertiesFeaturesQCOM(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceTilePropertiesFeaturesQCOM* toMap);

void handlemap_VkTilePropertiesQCOM(VulkanHandleMapping* handlemap, VkTilePropertiesQCOM* toMap);

#endif
#ifdef VK_SEC_amigo_profiling
void handlemap_VkPhysicalDeviceAmigoProfilingFeaturesSEC(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceAmigoProfilingFeaturesSEC* toMap);

void handlemap_VkAmigoProfilingSubmitInfoSEC(VulkanHandleMapping* handlemap,
                                             VkAmigoProfilingSubmitInfoSEC* toMap);

#endif
#ifdef VK_QCOM_multiview_per_view_viewports
void handlemap_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* toMap);

#endif
#ifdef VK_NV_ray_tracing_invocation_reorder
void handlemap_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV* toMap);

void handlemap_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* toMap);

#endif
#ifdef VK_EXT_mutable_descriptor_type
#endif
#ifdef VK_ARM_shader_core_builtins
void handlemap_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* toMap);

void handlemap_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM* toMap);

#endif
#ifdef VK_EXT_pipeline_library_group_handles
void handlemap_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(
    VulkanHandleMapping* handlemap, VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* toMap);

#endif
#ifdef VK_QCOM_multiview_per_view_render_areas
void handlemap_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* toMap);

void handlemap_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM(
    VulkanHandleMapping* handlemap, VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM* toMap);

#endif
#ifdef VK_EXT_attachment_feedback_loop_dynamic_state
void handlemap_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(
    VulkanHandleMapping* handlemap,
    VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* toMap);

#endif
#ifdef VK_KHR_acceleration_structure
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
#ifdef VK_EXT_mesh_shader
void handlemap_VkPhysicalDeviceMeshShaderFeaturesEXT(VulkanHandleMapping* handlemap,
                                                     VkPhysicalDeviceMeshShaderFeaturesEXT* toMap);

void handlemap_VkPhysicalDeviceMeshShaderPropertiesEXT(
    VulkanHandleMapping* handlemap, VkPhysicalDeviceMeshShaderPropertiesEXT* toMap);

void handlemap_VkDrawMeshTasksIndirectCommandEXT(VulkanHandleMapping* handlemap,
                                                 VkDrawMeshTasksIndirectCommandEXT* toMap);

#endif

}  // namespace vk
}  // namespace gfxstream