path: root/stream-servers/vulkan/cereal/common/goldfish_vk_deepcopy.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_deepcopy
//
// (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 "aemu/base/BumpPool.h"
#include "goldfish_vk_private_defs.h"
#include "vk_android_native_buffer.h"
#include "vulkan_gfxstream.h"
using android::base::Allocator;
using android::base::BumpPool;

namespace gfxstream {
namespace vk {

#ifdef VK_VERSION_1_0
void deepcopy_VkExtent2D(Allocator* alloc, VkStructureType rootType, const VkExtent2D* from,
                         VkExtent2D* to);

void deepcopy_VkExtent3D(Allocator* alloc, VkStructureType rootType, const VkExtent3D* from,
                         VkExtent3D* to);

void deepcopy_VkOffset2D(Allocator* alloc, VkStructureType rootType, const VkOffset2D* from,
                         VkOffset2D* to);

void deepcopy_VkOffset3D(Allocator* alloc, VkStructureType rootType, const VkOffset3D* from,
                         VkOffset3D* to);

void deepcopy_VkRect2D(Allocator* alloc, VkStructureType rootType, const VkRect2D* from,
                       VkRect2D* to);

void deepcopy_VkBaseInStructure(Allocator* alloc, VkStructureType rootType,
                                const VkBaseInStructure* from, VkBaseInStructure* to);

void deepcopy_VkBaseOutStructure(Allocator* alloc, VkStructureType rootType,
                                 const VkBaseOutStructure* from, VkBaseOutStructure* to);

void deepcopy_VkBufferMemoryBarrier(Allocator* alloc, VkStructureType rootType,
                                    const VkBufferMemoryBarrier* from, VkBufferMemoryBarrier* to);

void deepcopy_VkDispatchIndirectCommand(Allocator* alloc, VkStructureType rootType,
                                        const VkDispatchIndirectCommand* from,
                                        VkDispatchIndirectCommand* to);

void deepcopy_VkDrawIndexedIndirectCommand(Allocator* alloc, VkStructureType rootType,
                                           const VkDrawIndexedIndirectCommand* from,
                                           VkDrawIndexedIndirectCommand* to);

void deepcopy_VkDrawIndirectCommand(Allocator* alloc, VkStructureType rootType,
                                    const VkDrawIndirectCommand* from, VkDrawIndirectCommand* to);

void deepcopy_VkImageSubresourceRange(Allocator* alloc, VkStructureType rootType,
                                      const VkImageSubresourceRange* from,
                                      VkImageSubresourceRange* to);

void deepcopy_VkImageMemoryBarrier(Allocator* alloc, VkStructureType rootType,
                                   const VkImageMemoryBarrier* from, VkImageMemoryBarrier* to);

void deepcopy_VkMemoryBarrier(Allocator* alloc, VkStructureType rootType,
                              const VkMemoryBarrier* from, VkMemoryBarrier* to);

void deepcopy_VkPipelineCacheHeaderVersionOne(Allocator* alloc, VkStructureType rootType,
                                              const VkPipelineCacheHeaderVersionOne* from,
                                              VkPipelineCacheHeaderVersionOne* to);

void deepcopy_VkAllocationCallbacks(Allocator* alloc, VkStructureType rootType,
                                    const VkAllocationCallbacks* from, VkAllocationCallbacks* to);

void deepcopy_VkApplicationInfo(Allocator* alloc, VkStructureType rootType,
                                const VkApplicationInfo* from, VkApplicationInfo* to);

void deepcopy_VkFormatProperties(Allocator* alloc, VkStructureType rootType,
                                 const VkFormatProperties* from, VkFormatProperties* to);

void deepcopy_VkImageFormatProperties(Allocator* alloc, VkStructureType rootType,
                                      const VkImageFormatProperties* from,
                                      VkImageFormatProperties* to);

void deepcopy_VkInstanceCreateInfo(Allocator* alloc, VkStructureType rootType,
                                   const VkInstanceCreateInfo* from, VkInstanceCreateInfo* to);

void deepcopy_VkMemoryHeap(Allocator* alloc, VkStructureType rootType, const VkMemoryHeap* from,
                           VkMemoryHeap* to);

void deepcopy_VkMemoryType(Allocator* alloc, VkStructureType rootType, const VkMemoryType* from,
                           VkMemoryType* to);

void deepcopy_VkPhysicalDeviceFeatures(Allocator* alloc, VkStructureType rootType,
                                       const VkPhysicalDeviceFeatures* from,
                                       VkPhysicalDeviceFeatures* to);

void deepcopy_VkPhysicalDeviceLimits(Allocator* alloc, VkStructureType rootType,
                                     const VkPhysicalDeviceLimits* from,
                                     VkPhysicalDeviceLimits* to);

void deepcopy_VkPhysicalDeviceMemoryProperties(Allocator* alloc, VkStructureType rootType,
                                               const VkPhysicalDeviceMemoryProperties* from,
                                               VkPhysicalDeviceMemoryProperties* to);

void deepcopy_VkPhysicalDeviceSparseProperties(Allocator* alloc, VkStructureType rootType,
                                               const VkPhysicalDeviceSparseProperties* from,
                                               VkPhysicalDeviceSparseProperties* to);

void deepcopy_VkPhysicalDeviceProperties(Allocator* alloc, VkStructureType rootType,
                                         const VkPhysicalDeviceProperties* from,
                                         VkPhysicalDeviceProperties* to);

void deepcopy_VkQueueFamilyProperties(Allocator* alloc, VkStructureType rootType,
                                      const VkQueueFamilyProperties* from,
                                      VkQueueFamilyProperties* to);

void deepcopy_VkDeviceQueueCreateInfo(Allocator* alloc, VkStructureType rootType,
                                      const VkDeviceQueueCreateInfo* from,
                                      VkDeviceQueueCreateInfo* to);

void deepcopy_VkDeviceCreateInfo(Allocator* alloc, VkStructureType rootType,
                                 const VkDeviceCreateInfo* from, VkDeviceCreateInfo* to);

void deepcopy_VkExtensionProperties(Allocator* alloc, VkStructureType rootType,
                                    const VkExtensionProperties* from, VkExtensionProperties* to);

void deepcopy_VkLayerProperties(Allocator* alloc, VkStructureType rootType,
                                const VkLayerProperties* from, VkLayerProperties* to);

void deepcopy_VkSubmitInfo(Allocator* alloc, VkStructureType rootType, const VkSubmitInfo* from,
                           VkSubmitInfo* to);

void deepcopy_VkMappedMemoryRange(Allocator* alloc, VkStructureType rootType,
                                  const VkMappedMemoryRange* from, VkMappedMemoryRange* to);

void deepcopy_VkMemoryAllocateInfo(Allocator* alloc, VkStructureType rootType,
                                   const VkMemoryAllocateInfo* from, VkMemoryAllocateInfo* to);

void deepcopy_VkMemoryRequirements(Allocator* alloc, VkStructureType rootType,
                                   const VkMemoryRequirements* from, VkMemoryRequirements* to);

void deepcopy_VkSparseMemoryBind(Allocator* alloc, VkStructureType rootType,
                                 const VkSparseMemoryBind* from, VkSparseMemoryBind* to);

void deepcopy_VkSparseBufferMemoryBindInfo(Allocator* alloc, VkStructureType rootType,
                                           const VkSparseBufferMemoryBindInfo* from,
                                           VkSparseBufferMemoryBindInfo* to);

void deepcopy_VkSparseImageOpaqueMemoryBindInfo(Allocator* alloc, VkStructureType rootType,
                                                const VkSparseImageOpaqueMemoryBindInfo* from,
                                                VkSparseImageOpaqueMemoryBindInfo* to);

void deepcopy_VkImageSubresource(Allocator* alloc, VkStructureType rootType,
                                 const VkImageSubresource* from, VkImageSubresource* to);

void deepcopy_VkSparseImageMemoryBind(Allocator* alloc, VkStructureType rootType,
                                      const VkSparseImageMemoryBind* from,
                                      VkSparseImageMemoryBind* to);

void deepcopy_VkSparseImageMemoryBindInfo(Allocator* alloc, VkStructureType rootType,
                                          const VkSparseImageMemoryBindInfo* from,
                                          VkSparseImageMemoryBindInfo* to);

void deepcopy_VkBindSparseInfo(Allocator* alloc, VkStructureType rootType,
                               const VkBindSparseInfo* from, VkBindSparseInfo* to);

void deepcopy_VkSparseImageFormatProperties(Allocator* alloc, VkStructureType rootType,
                                            const VkSparseImageFormatProperties* from,
                                            VkSparseImageFormatProperties* to);

void deepcopy_VkSparseImageMemoryRequirements(Allocator* alloc, VkStructureType rootType,
                                              const VkSparseImageMemoryRequirements* from,
                                              VkSparseImageMemoryRequirements* to);

void deepcopy_VkFenceCreateInfo(Allocator* alloc, VkStructureType rootType,
                                const VkFenceCreateInfo* from, VkFenceCreateInfo* to);

void deepcopy_VkSemaphoreCreateInfo(Allocator* alloc, VkStructureType rootType,
                                    const VkSemaphoreCreateInfo* from, VkSemaphoreCreateInfo* to);

void deepcopy_VkEventCreateInfo(Allocator* alloc, VkStructureType rootType,
                                const VkEventCreateInfo* from, VkEventCreateInfo* to);

void deepcopy_VkQueryPoolCreateInfo(Allocator* alloc, VkStructureType rootType,
                                    const VkQueryPoolCreateInfo* from, VkQueryPoolCreateInfo* to);

void deepcopy_VkBufferCreateInfo(Allocator* alloc, VkStructureType rootType,
                                 const VkBufferCreateInfo* from, VkBufferCreateInfo* to);

void deepcopy_VkBufferViewCreateInfo(Allocator* alloc, VkStructureType rootType,
                                     const VkBufferViewCreateInfo* from,
                                     VkBufferViewCreateInfo* to);

void deepcopy_VkImageCreateInfo(Allocator* alloc, VkStructureType rootType,
                                const VkImageCreateInfo* from, VkImageCreateInfo* to);

void deepcopy_VkSubresourceLayout(Allocator* alloc, VkStructureType rootType,
                                  const VkSubresourceLayout* from, VkSubresourceLayout* to);

void deepcopy_VkComponentMapping(Allocator* alloc, VkStructureType rootType,
                                 const VkComponentMapping* from, VkComponentMapping* to);

void deepcopy_VkImageViewCreateInfo(Allocator* alloc, VkStructureType rootType,
                                    const VkImageViewCreateInfo* from, VkImageViewCreateInfo* to);

void deepcopy_VkShaderModuleCreateInfo(Allocator* alloc, VkStructureType rootType,
                                       const VkShaderModuleCreateInfo* from,
                                       VkShaderModuleCreateInfo* to);

void deepcopy_VkPipelineCacheCreateInfo(Allocator* alloc, VkStructureType rootType,
                                        const VkPipelineCacheCreateInfo* from,
                                        VkPipelineCacheCreateInfo* to);

void deepcopy_VkSpecializationMapEntry(Allocator* alloc, VkStructureType rootType,
                                       const VkSpecializationMapEntry* from,
                                       VkSpecializationMapEntry* to);

void deepcopy_VkSpecializationInfo(Allocator* alloc, VkStructureType rootType,
                                   const VkSpecializationInfo* from, VkSpecializationInfo* to);

void deepcopy_VkPipelineShaderStageCreateInfo(Allocator* alloc, VkStructureType rootType,
                                              const VkPipelineShaderStageCreateInfo* from,
                                              VkPipelineShaderStageCreateInfo* to);

void deepcopy_VkComputePipelineCreateInfo(Allocator* alloc, VkStructureType rootType,
                                          const VkComputePipelineCreateInfo* from,
                                          VkComputePipelineCreateInfo* to);

void deepcopy_VkVertexInputBindingDescription(Allocator* alloc, VkStructureType rootType,
                                              const VkVertexInputBindingDescription* from,
                                              VkVertexInputBindingDescription* to);

void deepcopy_VkVertexInputAttributeDescription(Allocator* alloc, VkStructureType rootType,
                                                const VkVertexInputAttributeDescription* from,
                                                VkVertexInputAttributeDescription* to);

void deepcopy_VkPipelineVertexInputStateCreateInfo(Allocator* alloc, VkStructureType rootType,
                                                   const VkPipelineVertexInputStateCreateInfo* from,
                                                   VkPipelineVertexInputStateCreateInfo* to);

void deepcopy_VkPipelineInputAssemblyStateCreateInfo(
    Allocator* alloc, VkStructureType rootType, const VkPipelineInputAssemblyStateCreateInfo* from,
    VkPipelineInputAssemblyStateCreateInfo* to);

void deepcopy_VkPipelineTessellationStateCreateInfo(
    Allocator* alloc, VkStructureType rootType, const VkPipelineTessellationStateCreateInfo* from,
    VkPipelineTessellationStateCreateInfo* to);

void deepcopy_VkViewport(Allocator* alloc, VkStructureType rootType, const VkViewport* from,
                         VkViewport* to);

void deepcopy_VkPipelineViewportStateCreateInfo(Allocator* alloc, VkStructureType rootType,
                                                const VkPipelineViewportStateCreateInfo* from,
                                                VkPipelineViewportStateCreateInfo* to);

void deepcopy_VkPipelineRasterizationStateCreateInfo(
    Allocator* alloc, VkStructureType rootType, const VkPipelineRasterizationStateCreateInfo* from,
    VkPipelineRasterizationStateCreateInfo* to);

void deepcopy_VkPipelineMultisampleStateCreateInfo(Allocator* alloc, VkStructureType rootType,
                                                   const VkPipelineMultisampleStateCreateInfo* from,
                                                   VkPipelineMultisampleStateCreateInfo* to);

void deepcopy_VkStencilOpState(Allocator* alloc, VkStructureType rootType,
                               const VkStencilOpState* from, VkStencilOpState* to);

void deepcopy_VkPipelineDepthStencilStateCreateInfo(
    Allocator* alloc, VkStructureType rootType, const VkPipelineDepthStencilStateCreateInfo* from,
    VkPipelineDepthStencilStateCreateInfo* to);

void deepcopy_VkPipelineColorBlendAttachmentState(Allocator* alloc, VkStructureType rootType,
                                                  const VkPipelineColorBlendAttachmentState* from,
                                                  VkPipelineColorBlendAttachmentState* to);

void deepcopy_VkPipelineColorBlendStateCreateInfo(Allocator* alloc, VkStructureType rootType,
                                                  const VkPipelineColorBlendStateCreateInfo* from,
                                                  VkPipelineColorBlendStateCreateInfo* to);

void deepcopy_VkPipelineDynamicStateCreateInfo(Allocator* alloc, VkStructureType rootType,
                                               const VkPipelineDynamicStateCreateInfo* from,
                                               VkPipelineDynamicStateCreateInfo* to);

void deepcopy_VkGraphicsPipelineCreateInfo(Allocator* alloc, VkStructureType rootType,
                                           const VkGraphicsPipelineCreateInfo* from,
                                           VkGraphicsPipelineCreateInfo* to);

void deepcopy_VkPushConstantRange(Allocator* alloc, VkStructureType rootType,
                                  const VkPushConstantRange* from, VkPushConstantRange* to);

void deepcopy_VkPipelineLayoutCreateInfo(Allocator* alloc, VkStructureType rootType,
                                         const VkPipelineLayoutCreateInfo* from,
                                         VkPipelineLayoutCreateInfo* to);

void deepcopy_VkSamplerCreateInfo(Allocator* alloc, VkStructureType rootType,
                                  const VkSamplerCreateInfo* from, VkSamplerCreateInfo* to);

void deepcopy_VkCopyDescriptorSet(Allocator* alloc, VkStructureType rootType,
                                  const VkCopyDescriptorSet* from, VkCopyDescriptorSet* to);

void deepcopy_VkDescriptorBufferInfo(Allocator* alloc, VkStructureType rootType,
                                     const VkDescriptorBufferInfo* from,
                                     VkDescriptorBufferInfo* to);

void deepcopy_VkDescriptorImageInfo(Allocator* alloc, VkStructureType rootType,
                                    const VkDescriptorImageInfo* from, VkDescriptorImageInfo* to);

void deepcopy_VkDescriptorPoolSize(Allocator* alloc, VkStructureType rootType,
                                   const VkDescriptorPoolSize* from, VkDescriptorPoolSize* to);

void deepcopy_VkDescriptorPoolCreateInfo(Allocator* alloc, VkStructureType rootType,
                                         const VkDescriptorPoolCreateInfo* from,
                                         VkDescriptorPoolCreateInfo* to);

void deepcopy_VkDescriptorSetAllocateInfo(Allocator* alloc, VkStructureType rootType,
                                          const VkDescriptorSetAllocateInfo* from,
                                          VkDescriptorSetAllocateInfo* to);

void deepcopy_VkDescriptorSetLayoutBinding(Allocator* alloc, VkStructureType rootType,
                                           const VkDescriptorSetLayoutBinding* from,
                                           VkDescriptorSetLayoutBinding* to);

void deepcopy_VkDescriptorSetLayoutCreateInfo(Allocator* alloc, VkStructureType rootType,
                                              const VkDescriptorSetLayoutCreateInfo* from,
                                              VkDescriptorSetLayoutCreateInfo* to);

void deepcopy_VkWriteDescriptorSet(Allocator* alloc, VkStructureType rootType,
                                   const VkWriteDescriptorSet* from, VkWriteDescriptorSet* to);

void deepcopy_VkAttachmentDescription(Allocator* alloc, VkStructureType rootType,
                                      const VkAttachmentDescription* from,
                                      VkAttachmentDescription* to);

void deepcopy_VkAttachmentReference(Allocator* alloc, VkStructureType rootType,
                                    const VkAttachmentReference* from, VkAttachmentReference* to);

void deepcopy_VkFramebufferCreateInfo(Allocator* alloc, VkStructureType rootType,
                                      const VkFramebufferCreateInfo* from,
                                      VkFramebufferCreateInfo* to);

void deepcopy_VkSubpassDescription(Allocator* alloc, VkStructureType rootType,
                                   const VkSubpassDescription* from, VkSubpassDescription* to);

void deepcopy_VkSubpassDependency(Allocator* alloc, VkStructureType rootType,
                                  const VkSubpassDependency* from, VkSubpassDependency* to);

void deepcopy_VkRenderPassCreateInfo(Allocator* alloc, VkStructureType rootType,
                                     const VkRenderPassCreateInfo* from,
                                     VkRenderPassCreateInfo* to);

void deepcopy_VkCommandPoolCreateInfo(Allocator* alloc, VkStructureType rootType,
                                      const VkCommandPoolCreateInfo* from,
                                      VkCommandPoolCreateInfo* to);

void deepcopy_VkCommandBufferAllocateInfo(Allocator* alloc, VkStructureType rootType,
                                          const VkCommandBufferAllocateInfo* from,
                                          VkCommandBufferAllocateInfo* to);

void deepcopy_VkCommandBufferInheritanceInfo(Allocator* alloc, VkStructureType rootType,
                                             const VkCommandBufferInheritanceInfo* from,
                                             VkCommandBufferInheritanceInfo* to);

void deepcopy_VkCommandBufferBeginInfo(Allocator* alloc, VkStructureType rootType,
                                       const VkCommandBufferBeginInfo* from,
                                       VkCommandBufferBeginInfo* to);

void deepcopy_VkBufferCopy(Allocator* alloc, VkStructureType rootType, const VkBufferCopy* from,
                           VkBufferCopy* to);

void deepcopy_VkImageSubresourceLayers(Allocator* alloc, VkStructureType rootType,
                                       const VkImageSubresourceLayers* from,
                                       VkImageSubresourceLayers* to);

void deepcopy_VkBufferImageCopy(Allocator* alloc, VkStructureType rootType,
                                const VkBufferImageCopy* from, VkBufferImageCopy* to);

void deepcopy_VkClearColorValue(Allocator* alloc, VkStructureType rootType,
                                const VkClearColorValue* from, VkClearColorValue* to);

void deepcopy_VkClearDepthStencilValue(Allocator* alloc, VkStructureType rootType,
                                       const VkClearDepthStencilValue* from,
                                       VkClearDepthStencilValue* to);

void deepcopy_VkClearValue(Allocator* alloc, VkStructureType rootType, const VkClearValue* from,
                           VkClearValue* to);

void deepcopy_VkClearAttachment(Allocator* alloc, VkStructureType rootType,
                                const VkClearAttachment* from, VkClearAttachment* to);

void deepcopy_VkClearRect(Allocator* alloc, VkStructureType rootType, const VkClearRect* from,
                          VkClearRect* to);

void deepcopy_VkImageBlit(Allocator* alloc, VkStructureType rootType, const VkImageBlit* from,
                          VkImageBlit* to);

void deepcopy_VkImageCopy(Allocator* alloc, VkStructureType rootType, const VkImageCopy* from,
                          VkImageCopy* to);

void deepcopy_VkImageResolve(Allocator* alloc, VkStructureType rootType, const VkImageResolve* from,
                             VkImageResolve* to);

void deepcopy_VkRenderPassBeginInfo(Allocator* alloc, VkStructureType rootType,
                                    const VkRenderPassBeginInfo* from, VkRenderPassBeginInfo* to);

#endif
#ifdef VK_VERSION_1_1
void deepcopy_VkPhysicalDeviceSubgroupProperties(Allocator* alloc, VkStructureType rootType,
                                                 const VkPhysicalDeviceSubgroupProperties* from,
                                                 VkPhysicalDeviceSubgroupProperties* to);

void deepcopy_VkBindBufferMemoryInfo(Allocator* alloc, VkStructureType rootType,
                                     const VkBindBufferMemoryInfo* from,
                                     VkBindBufferMemoryInfo* to);

void deepcopy_VkBindImageMemoryInfo(Allocator* alloc, VkStructureType rootType,
                                    const VkBindImageMemoryInfo* from, VkBindImageMemoryInfo* to);

void deepcopy_VkPhysicalDevice16BitStorageFeatures(Allocator* alloc, VkStructureType rootType,
                                                   const VkPhysicalDevice16BitStorageFeatures* from,
                                                   VkPhysicalDevice16BitStorageFeatures* to);

void deepcopy_VkMemoryDedicatedRequirements(Allocator* alloc, VkStructureType rootType,
                                            const VkMemoryDedicatedRequirements* from,
                                            VkMemoryDedicatedRequirements* to);

void deepcopy_VkMemoryDedicatedAllocateInfo(Allocator* alloc, VkStructureType rootType,
                                            const VkMemoryDedicatedAllocateInfo* from,
                                            VkMemoryDedicatedAllocateInfo* to);

void deepcopy_VkMemoryAllocateFlagsInfo(Allocator* alloc, VkStructureType rootType,
                                        const VkMemoryAllocateFlagsInfo* from,
                                        VkMemoryAllocateFlagsInfo* to);

void deepcopy_VkDeviceGroupRenderPassBeginInfo(Allocator* alloc, VkStructureType rootType,
                                               const VkDeviceGroupRenderPassBeginInfo* from,
                                               VkDeviceGroupRenderPassBeginInfo* to);

void deepcopy_VkDeviceGroupCommandBufferBeginInfo(Allocator* alloc, VkStructureType rootType,
                                                  const VkDeviceGroupCommandBufferBeginInfo* from,
                                                  VkDeviceGroupCommandBufferBeginInfo* to);

void deepcopy_VkDeviceGroupSubmitInfo(Allocator* alloc, VkStructureType rootType,
                                      const VkDeviceGroupSubmitInfo* from,
                                      VkDeviceGroupSubmitInfo* to);

void deepcopy_VkDeviceGroupBindSparseInfo(Allocator* alloc, VkStructureType rootType,
                                          const VkDeviceGroupBindSparseInfo* from,
                                          VkDeviceGroupBindSparseInfo* to);

void deepcopy_VkBindBufferMemoryDeviceGroupInfo(Allocator* alloc, VkStructureType rootType,
                                                const VkBindBufferMemoryDeviceGroupInfo* from,
                                                VkBindBufferMemoryDeviceGroupInfo* to);

void deepcopy_VkBindImageMemoryDeviceGroupInfo(Allocator* alloc, VkStructureType rootType,
                                               const VkBindImageMemoryDeviceGroupInfo* from,
                                               VkBindImageMemoryDeviceGroupInfo* to);

void deepcopy_VkPhysicalDeviceGroupProperties(Allocator* alloc, VkStructureType rootType,
                                              const VkPhysicalDeviceGroupProperties* from,
                                              VkPhysicalDeviceGroupProperties* to);

void deepcopy_VkDeviceGroupDeviceCreateInfo(Allocator* alloc, VkStructureType rootType,
                                            const VkDeviceGroupDeviceCreateInfo* from,
                                            VkDeviceGroupDeviceCreateInfo* to);

void deepcopy_VkBufferMemoryRequirementsInfo2(Allocator* alloc, VkStructureType rootType,
                                              const VkBufferMemoryRequirementsInfo2* from,
                                              VkBufferMemoryRequirementsInfo2* to);

void deepcopy_VkImageMemoryRequirementsInfo2(Allocator* alloc, VkStructureType rootType,
                                             const VkImageMemoryRequirementsInfo2* from,
                                             VkImageMemoryRequirementsInfo2* to);

void deepcopy_VkImageSparseMemoryRequirementsInfo2(Allocator* alloc, VkStructureType rootType,
                                                   const VkImageSparseMemoryRequirementsInfo2* from,
                                                   VkImageSparseMemoryRequirementsInfo2* to);

void deepcopy_VkMemoryRequirements2(Allocator* alloc, VkStructureType rootType,
                                    const VkMemoryRequirements2* from, VkMemoryRequirements2* to);

void deepcopy_VkSparseImageMemoryRequirements2(Allocator* alloc, VkStructureType rootType,
                                               const VkSparseImageMemoryRequirements2* from,
                                               VkSparseImageMemoryRequirements2* to);

void deepcopy_VkPhysicalDeviceFeatures2(Allocator* alloc, VkStructureType rootType,
                                        const VkPhysicalDeviceFeatures2* from,
                                        VkPhysicalDeviceFeatures2* to);

void deepcopy_VkPhysicalDeviceProperties2(Allocator* alloc, VkStructureType rootType,
                                          const VkPhysicalDeviceProperties2* from,
                                          VkPhysicalDeviceProperties2* to);

void deepcopy_VkFormatProperties2(Allocator* alloc, VkStructureType rootType,
                                  const VkFormatProperties2* from, VkFormatProperties2* to);

void deepcopy_VkImageFormatProperties2(Allocator* alloc, VkStructureType rootType,
                                       const VkImageFormatProperties2* from,
                                       VkImageFormatProperties2* to);

void deepcopy_VkPhysicalDeviceImageFormatInfo2(Allocator* alloc, VkStructureType rootType,
                                               const VkPhysicalDeviceImageFormatInfo2* from,
                                               VkPhysicalDeviceImageFormatInfo2* to);

void deepcopy_VkQueueFamilyProperties2(Allocator* alloc, VkStructureType rootType,
                                       const VkQueueFamilyProperties2* from,
                                       VkQueueFamilyProperties2* to);

void deepcopy_VkPhysicalDeviceMemoryProperties2(Allocator* alloc, VkStructureType rootType,
                                                const VkPhysicalDeviceMemoryProperties2* from,
                                                VkPhysicalDeviceMemoryProperties2* to);

void deepcopy_VkSparseImageFormatProperties2(Allocator* alloc, VkStructureType rootType,
                                             const VkSparseImageFormatProperties2* from,
                                             VkSparseImageFormatProperties2* to);

void deepcopy_VkPhysicalDeviceSparseImageFormatInfo2(
    Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceSparseImageFormatInfo2* from,
    VkPhysicalDeviceSparseImageFormatInfo2* to);

void deepcopy_VkPhysicalDevicePointClippingProperties(
    Allocator* alloc, VkStructureType rootType, const VkPhysicalDevicePointClippingProperties* from,
    VkPhysicalDevicePointClippingProperties* to);

void deepcopy_VkInputAttachmentAspectReference(Allocator* alloc, VkStructureType rootType,
                                               const VkInputAttachmentAspectReference* from,
                                               VkInputAttachmentAspectReference* to);

void deepcopy_VkRenderPassInputAttachmentAspectCreateInfo(
    Allocator* alloc, VkStructureType rootType,
    const VkRenderPassInputAttachmentAspectCreateInfo* from,
    VkRenderPassInputAttachmentAspectCreateInfo* to);

void deepcopy_VkImageViewUsageCreateInfo(Allocator* alloc, VkStructureType rootType,
                                         const VkImageViewUsageCreateInfo* from,
                                         VkImageViewUsageCreateInfo* to);

void deepcopy_VkPipelineTessellationDomainOriginStateCreateInfo(
    Allocator* alloc, VkStructureType rootType,
    const VkPipelineTessellationDomainOriginStateCreateInfo* from,
    VkPipelineTessellationDomainOriginStateCreateInfo* to);

void deepcopy_VkRenderPassMultiviewCreateInfo(Allocator* alloc, VkStructureType rootType,
                                              const VkRenderPassMultiviewCreateInfo* from,
                                              VkRenderPassMultiviewCreateInfo* to);

void deepcopy_VkPhysicalDeviceMultiviewFeatures(Allocator* alloc, VkStructureType rootType,
                                                const VkPhysicalDeviceMultiviewFeatures* from,
                                                VkPhysicalDeviceMultiviewFeatures* to);

void deepcopy_VkPhysicalDeviceMultiviewProperties(Allocator* alloc, VkStructureType rootType,
                                                  const VkPhysicalDeviceMultiviewProperties* from,
                                                  VkPhysicalDeviceMultiviewProperties* to);

void deepcopy_VkPhysicalDeviceVariablePointersFeatures(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceVariablePointersFeatures* from,
    VkPhysicalDeviceVariablePointersFeatures* to);

DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceVariablePointersFeatures,
                      deepcopy_VkPhysicalDeviceVariablePointerFeatures)

void deepcopy_VkPhysicalDeviceProtectedMemoryFeatures(
    Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceProtectedMemoryFeatures* from,
    VkPhysicalDeviceProtectedMemoryFeatures* to);

void deepcopy_VkPhysicalDeviceProtectedMemoryProperties(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceProtectedMemoryProperties* from,
    VkPhysicalDeviceProtectedMemoryProperties* to);

void deepcopy_VkDeviceQueueInfo2(Allocator* alloc, VkStructureType rootType,
                                 const VkDeviceQueueInfo2* from, VkDeviceQueueInfo2* to);

void deepcopy_VkProtectedSubmitInfo(Allocator* alloc, VkStructureType rootType,
                                    const VkProtectedSubmitInfo* from, VkProtectedSubmitInfo* to);

void deepcopy_VkSamplerYcbcrConversionCreateInfo(Allocator* alloc, VkStructureType rootType,
                                                 const VkSamplerYcbcrConversionCreateInfo* from,
                                                 VkSamplerYcbcrConversionCreateInfo* to);

void deepcopy_VkSamplerYcbcrConversionInfo(Allocator* alloc, VkStructureType rootType,
                                           const VkSamplerYcbcrConversionInfo* from,
                                           VkSamplerYcbcrConversionInfo* to);

void deepcopy_VkBindImagePlaneMemoryInfo(Allocator* alloc, VkStructureType rootType,
                                         const VkBindImagePlaneMemoryInfo* from,
                                         VkBindImagePlaneMemoryInfo* to);

void deepcopy_VkImagePlaneMemoryRequirementsInfo(Allocator* alloc, VkStructureType rootType,
                                                 const VkImagePlaneMemoryRequirementsInfo* from,
                                                 VkImagePlaneMemoryRequirementsInfo* to);

void deepcopy_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceSamplerYcbcrConversionFeatures* from,
    VkPhysicalDeviceSamplerYcbcrConversionFeatures* to);

void deepcopy_VkSamplerYcbcrConversionImageFormatProperties(
    Allocator* alloc, VkStructureType rootType,
    const VkSamplerYcbcrConversionImageFormatProperties* from,
    VkSamplerYcbcrConversionImageFormatProperties* to);

void deepcopy_VkDescriptorUpdateTemplateEntry(Allocator* alloc, VkStructureType rootType,
                                              const VkDescriptorUpdateTemplateEntry* from,
                                              VkDescriptorUpdateTemplateEntry* to);

void deepcopy_VkDescriptorUpdateTemplateCreateInfo(Allocator* alloc, VkStructureType rootType,
                                                   const VkDescriptorUpdateTemplateCreateInfo* from,
                                                   VkDescriptorUpdateTemplateCreateInfo* to);

void deepcopy_VkExternalMemoryProperties(Allocator* alloc, VkStructureType rootType,
                                         const VkExternalMemoryProperties* from,
                                         VkExternalMemoryProperties* to);

void deepcopy_VkPhysicalDeviceExternalImageFormatInfo(
    Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceExternalImageFormatInfo* from,
    VkPhysicalDeviceExternalImageFormatInfo* to);

void deepcopy_VkExternalImageFormatProperties(Allocator* alloc, VkStructureType rootType,
                                              const VkExternalImageFormatProperties* from,
                                              VkExternalImageFormatProperties* to);

void deepcopy_VkPhysicalDeviceExternalBufferInfo(Allocator* alloc, VkStructureType rootType,
                                                 const VkPhysicalDeviceExternalBufferInfo* from,
                                                 VkPhysicalDeviceExternalBufferInfo* to);

void deepcopy_VkExternalBufferProperties(Allocator* alloc, VkStructureType rootType,
                                         const VkExternalBufferProperties* from,
                                         VkExternalBufferProperties* to);

void deepcopy_VkPhysicalDeviceIDProperties(Allocator* alloc, VkStructureType rootType,
                                           const VkPhysicalDeviceIDProperties* from,
                                           VkPhysicalDeviceIDProperties* to);

void deepcopy_VkExternalMemoryImageCreateInfo(Allocator* alloc, VkStructureType rootType,
                                              const VkExternalMemoryImageCreateInfo* from,
                                              VkExternalMemoryImageCreateInfo* to);

void deepcopy_VkExternalMemoryBufferCreateInfo(Allocator* alloc, VkStructureType rootType,
                                               const VkExternalMemoryBufferCreateInfo* from,
                                               VkExternalMemoryBufferCreateInfo* to);

void deepcopy_VkExportMemoryAllocateInfo(Allocator* alloc, VkStructureType rootType,
                                         const VkExportMemoryAllocateInfo* from,
                                         VkExportMemoryAllocateInfo* to);

void deepcopy_VkPhysicalDeviceExternalFenceInfo(Allocator* alloc, VkStructureType rootType,
                                                const VkPhysicalDeviceExternalFenceInfo* from,
                                                VkPhysicalDeviceExternalFenceInfo* to);

void deepcopy_VkExternalFenceProperties(Allocator* alloc, VkStructureType rootType,
                                        const VkExternalFenceProperties* from,
                                        VkExternalFenceProperties* to);

void deepcopy_VkExportFenceCreateInfo(Allocator* alloc, VkStructureType rootType,
                                      const VkExportFenceCreateInfo* from,
                                      VkExportFenceCreateInfo* to);

void deepcopy_VkExportSemaphoreCreateInfo(Allocator* alloc, VkStructureType rootType,
                                          const VkExportSemaphoreCreateInfo* from,
                                          VkExportSemaphoreCreateInfo* to);

void deepcopy_VkPhysicalDeviceExternalSemaphoreInfo(
    Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceExternalSemaphoreInfo* from,
    VkPhysicalDeviceExternalSemaphoreInfo* to);

void deepcopy_VkExternalSemaphoreProperties(Allocator* alloc, VkStructureType rootType,
                                            const VkExternalSemaphoreProperties* from,
                                            VkExternalSemaphoreProperties* to);

void deepcopy_VkPhysicalDeviceMaintenance3Properties(
    Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceMaintenance3Properties* from,
    VkPhysicalDeviceMaintenance3Properties* to);

void deepcopy_VkDescriptorSetLayoutSupport(Allocator* alloc, VkStructureType rootType,
                                           const VkDescriptorSetLayoutSupport* from,
                                           VkDescriptorSetLayoutSupport* to);

void deepcopy_VkPhysicalDeviceShaderDrawParametersFeatures(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceShaderDrawParametersFeatures* from,
    VkPhysicalDeviceShaderDrawParametersFeatures* to);

DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceShaderDrawParametersFeatures,
                      deepcopy_VkPhysicalDeviceShaderDrawParameterFeatures)

#endif
#ifdef VK_VERSION_1_2
void deepcopy_VkPhysicalDeviceVulkan11Features(Allocator* alloc, VkStructureType rootType,
                                               const VkPhysicalDeviceVulkan11Features* from,
                                               VkPhysicalDeviceVulkan11Features* to);

void deepcopy_VkPhysicalDeviceVulkan11Properties(Allocator* alloc, VkStructureType rootType,
                                                 const VkPhysicalDeviceVulkan11Properties* from,
                                                 VkPhysicalDeviceVulkan11Properties* to);

void deepcopy_VkPhysicalDeviceVulkan12Features(Allocator* alloc, VkStructureType rootType,
                                               const VkPhysicalDeviceVulkan12Features* from,
                                               VkPhysicalDeviceVulkan12Features* to);

void deepcopy_VkConformanceVersion(Allocator* alloc, VkStructureType rootType,
                                   const VkConformanceVersion* from, VkConformanceVersion* to);

void deepcopy_VkPhysicalDeviceVulkan12Properties(Allocator* alloc, VkStructureType rootType,
                                                 const VkPhysicalDeviceVulkan12Properties* from,
                                                 VkPhysicalDeviceVulkan12Properties* to);

void deepcopy_VkImageFormatListCreateInfo(Allocator* alloc, VkStructureType rootType,
                                          const VkImageFormatListCreateInfo* from,
                                          VkImageFormatListCreateInfo* to);

void deepcopy_VkAttachmentDescription2(Allocator* alloc, VkStructureType rootType,
                                       const VkAttachmentDescription2* from,
                                       VkAttachmentDescription2* to);

void deepcopy_VkAttachmentReference2(Allocator* alloc, VkStructureType rootType,
                                     const VkAttachmentReference2* from,
                                     VkAttachmentReference2* to);

void deepcopy_VkSubpassDescription2(Allocator* alloc, VkStructureType rootType,
                                    const VkSubpassDescription2* from, VkSubpassDescription2* to);

void deepcopy_VkSubpassDependency2(Allocator* alloc, VkStructureType rootType,
                                   const VkSubpassDependency2* from, VkSubpassDependency2* to);

void deepcopy_VkRenderPassCreateInfo2(Allocator* alloc, VkStructureType rootType,
                                      const VkRenderPassCreateInfo2* from,
                                      VkRenderPassCreateInfo2* to);

void deepcopy_VkSubpassBeginInfo(Allocator* alloc, VkStructureType rootType,
                                 const VkSubpassBeginInfo* from, VkSubpassBeginInfo* to);

void deepcopy_VkSubpassEndInfo(Allocator* alloc, VkStructureType rootType,
                               const VkSubpassEndInfo* from, VkSubpassEndInfo* to);

void deepcopy_VkPhysicalDevice8BitStorageFeatures(Allocator* alloc, VkStructureType rootType,
                                                  const VkPhysicalDevice8BitStorageFeatures* from,
                                                  VkPhysicalDevice8BitStorageFeatures* to);

void deepcopy_VkPhysicalDeviceDriverProperties(Allocator* alloc, VkStructureType rootType,
                                               const VkPhysicalDeviceDriverProperties* from,
                                               VkPhysicalDeviceDriverProperties* to);

void deepcopy_VkPhysicalDeviceShaderAtomicInt64Features(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceShaderAtomicInt64Features* from,
    VkPhysicalDeviceShaderAtomicInt64Features* to);

void deepcopy_VkPhysicalDeviceShaderFloat16Int8Features(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceShaderFloat16Int8Features* from,
    VkPhysicalDeviceShaderFloat16Int8Features* to);

void deepcopy_VkPhysicalDeviceFloatControlsProperties(
    Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceFloatControlsProperties* from,
    VkPhysicalDeviceFloatControlsProperties* to);

void deepcopy_VkDescriptorSetLayoutBindingFlagsCreateInfo(
    Allocator* alloc, VkStructureType rootType,
    const VkDescriptorSetLayoutBindingFlagsCreateInfo* from,
    VkDescriptorSetLayoutBindingFlagsCreateInfo* to);

void deepcopy_VkPhysicalDeviceDescriptorIndexingFeatures(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceDescriptorIndexingFeatures* from,
    VkPhysicalDeviceDescriptorIndexingFeatures* to);

void deepcopy_VkPhysicalDeviceDescriptorIndexingProperties(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceDescriptorIndexingProperties* from,
    VkPhysicalDeviceDescriptorIndexingProperties* to);

void deepcopy_VkDescriptorSetVariableDescriptorCountAllocateInfo(
    Allocator* alloc, VkStructureType rootType,
    const VkDescriptorSetVariableDescriptorCountAllocateInfo* from,
    VkDescriptorSetVariableDescriptorCountAllocateInfo* to);

void deepcopy_VkDescriptorSetVariableDescriptorCountLayoutSupport(
    Allocator* alloc, VkStructureType rootType,
    const VkDescriptorSetVariableDescriptorCountLayoutSupport* from,
    VkDescriptorSetVariableDescriptorCountLayoutSupport* to);

void deepcopy_VkSubpassDescriptionDepthStencilResolve(
    Allocator* alloc, VkStructureType rootType, const VkSubpassDescriptionDepthStencilResolve* from,
    VkSubpassDescriptionDepthStencilResolve* to);

void deepcopy_VkPhysicalDeviceDepthStencilResolveProperties(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceDepthStencilResolveProperties* from,
    VkPhysicalDeviceDepthStencilResolveProperties* to);

void deepcopy_VkPhysicalDeviceScalarBlockLayoutFeatures(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceScalarBlockLayoutFeatures* from,
    VkPhysicalDeviceScalarBlockLayoutFeatures* to);

void deepcopy_VkImageStencilUsageCreateInfo(Allocator* alloc, VkStructureType rootType,
                                            const VkImageStencilUsageCreateInfo* from,
                                            VkImageStencilUsageCreateInfo* to);

void deepcopy_VkSamplerReductionModeCreateInfo(Allocator* alloc, VkStructureType rootType,
                                               const VkSamplerReductionModeCreateInfo* from,
                                               VkSamplerReductionModeCreateInfo* to);

void deepcopy_VkPhysicalDeviceSamplerFilterMinmaxProperties(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceSamplerFilterMinmaxProperties* from,
    VkPhysicalDeviceSamplerFilterMinmaxProperties* to);

void deepcopy_VkPhysicalDeviceVulkanMemoryModelFeatures(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceVulkanMemoryModelFeatures* from,
    VkPhysicalDeviceVulkanMemoryModelFeatures* to);

void deepcopy_VkPhysicalDeviceImagelessFramebufferFeatures(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceImagelessFramebufferFeatures* from,
    VkPhysicalDeviceImagelessFramebufferFeatures* to);

void deepcopy_VkFramebufferAttachmentImageInfo(Allocator* alloc, VkStructureType rootType,
                                               const VkFramebufferAttachmentImageInfo* from,
                                               VkFramebufferAttachmentImageInfo* to);

void deepcopy_VkFramebufferAttachmentsCreateInfo(Allocator* alloc, VkStructureType rootType,
                                                 const VkFramebufferAttachmentsCreateInfo* from,
                                                 VkFramebufferAttachmentsCreateInfo* to);

void deepcopy_VkRenderPassAttachmentBeginInfo(Allocator* alloc, VkStructureType rootType,
                                              const VkRenderPassAttachmentBeginInfo* from,
                                              VkRenderPassAttachmentBeginInfo* to);

void deepcopy_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceUniformBufferStandardLayoutFeatures* from,
    VkPhysicalDeviceUniformBufferStandardLayoutFeatures* to);

void deepcopy_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* from,
    VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* to);

void deepcopy_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* from,
    VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* to);

void deepcopy_VkAttachmentReferenceStencilLayout(Allocator* alloc, VkStructureType rootType,
                                                 const VkAttachmentReferenceStencilLayout* from,
                                                 VkAttachmentReferenceStencilLayout* to);

void deepcopy_VkAttachmentDescriptionStencilLayout(Allocator* alloc, VkStructureType rootType,
                                                   const VkAttachmentDescriptionStencilLayout* from,
                                                   VkAttachmentDescriptionStencilLayout* to);

void deepcopy_VkPhysicalDeviceHostQueryResetFeatures(
    Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceHostQueryResetFeatures* from,
    VkPhysicalDeviceHostQueryResetFeatures* to);

void deepcopy_VkPhysicalDeviceTimelineSemaphoreFeatures(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceTimelineSemaphoreFeatures* from,
    VkPhysicalDeviceTimelineSemaphoreFeatures* to);

void deepcopy_VkPhysicalDeviceTimelineSemaphoreProperties(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceTimelineSemaphoreProperties* from,
    VkPhysicalDeviceTimelineSemaphoreProperties* to);

void deepcopy_VkSemaphoreTypeCreateInfo(Allocator* alloc, VkStructureType rootType,
                                        const VkSemaphoreTypeCreateInfo* from,
                                        VkSemaphoreTypeCreateInfo* to);

void deepcopy_VkTimelineSemaphoreSubmitInfo(Allocator* alloc, VkStructureType rootType,
                                            const VkTimelineSemaphoreSubmitInfo* from,
                                            VkTimelineSemaphoreSubmitInfo* to);

void deepcopy_VkSemaphoreWaitInfo(Allocator* alloc, VkStructureType rootType,
                                  const VkSemaphoreWaitInfo* from, VkSemaphoreWaitInfo* to);

void deepcopy_VkSemaphoreSignalInfo(Allocator* alloc, VkStructureType rootType,
                                    const VkSemaphoreSignalInfo* from, VkSemaphoreSignalInfo* to);

void deepcopy_VkPhysicalDeviceBufferDeviceAddressFeatures(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceBufferDeviceAddressFeatures* from,
    VkPhysicalDeviceBufferDeviceAddressFeatures* to);

void deepcopy_VkBufferDeviceAddressInfo(Allocator* alloc, VkStructureType rootType,
                                        const VkBufferDeviceAddressInfo* from,
                                        VkBufferDeviceAddressInfo* to);

void deepcopy_VkBufferOpaqueCaptureAddressCreateInfo(
    Allocator* alloc, VkStructureType rootType, const VkBufferOpaqueCaptureAddressCreateInfo* from,
    VkBufferOpaqueCaptureAddressCreateInfo* to);

void deepcopy_VkMemoryOpaqueCaptureAddressAllocateInfo(
    Allocator* alloc, VkStructureType rootType,
    const VkMemoryOpaqueCaptureAddressAllocateInfo* from,
    VkMemoryOpaqueCaptureAddressAllocateInfo* to);

void deepcopy_VkDeviceMemoryOpaqueCaptureAddressInfo(
    Allocator* alloc, VkStructureType rootType, const VkDeviceMemoryOpaqueCaptureAddressInfo* from,
    VkDeviceMemoryOpaqueCaptureAddressInfo* to);

#endif
#ifdef VK_VERSION_1_3
void deepcopy_VkPhysicalDeviceVulkan13Features(Allocator* alloc, VkStructureType rootType,
                                               const VkPhysicalDeviceVulkan13Features* from,
                                               VkPhysicalDeviceVulkan13Features* to);

void deepcopy_VkPhysicalDeviceVulkan13Properties(Allocator* alloc, VkStructureType rootType,
                                                 const VkPhysicalDeviceVulkan13Properties* from,
                                                 VkPhysicalDeviceVulkan13Properties* to);

void deepcopy_VkPipelineCreationFeedback(Allocator* alloc, VkStructureType rootType,
                                         const VkPipelineCreationFeedback* from,
                                         VkPipelineCreationFeedback* to);

void deepcopy_VkPipelineCreationFeedbackCreateInfo(Allocator* alloc, VkStructureType rootType,
                                                   const VkPipelineCreationFeedbackCreateInfo* from,
                                                   VkPipelineCreationFeedbackCreateInfo* to);

void deepcopy_VkPhysicalDeviceShaderTerminateInvocationFeatures(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceShaderTerminateInvocationFeatures* from,
    VkPhysicalDeviceShaderTerminateInvocationFeatures* to);

void deepcopy_VkPhysicalDeviceToolProperties(Allocator* alloc, VkStructureType rootType,
                                             const VkPhysicalDeviceToolProperties* from,
                                             VkPhysicalDeviceToolProperties* to);

void deepcopy_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* from,
    VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* to);

void deepcopy_VkPhysicalDevicePrivateDataFeatures(Allocator* alloc, VkStructureType rootType,
                                                  const VkPhysicalDevicePrivateDataFeatures* from,
                                                  VkPhysicalDevicePrivateDataFeatures* to);

void deepcopy_VkDevicePrivateDataCreateInfo(Allocator* alloc, VkStructureType rootType,
                                            const VkDevicePrivateDataCreateInfo* from,
                                            VkDevicePrivateDataCreateInfo* to);

void deepcopy_VkPrivateDataSlotCreateInfo(Allocator* alloc, VkStructureType rootType,
                                          const VkPrivateDataSlotCreateInfo* from,
                                          VkPrivateDataSlotCreateInfo* to);

void deepcopy_VkPhysicalDevicePipelineCreationCacheControlFeatures(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDevicePipelineCreationCacheControlFeatures* from,
    VkPhysicalDevicePipelineCreationCacheControlFeatures* to);

void deepcopy_VkMemoryBarrier2(Allocator* alloc, VkStructureType rootType,
                               const VkMemoryBarrier2* from, VkMemoryBarrier2* to);

void deepcopy_VkBufferMemoryBarrier2(Allocator* alloc, VkStructureType rootType,
                                     const VkBufferMemoryBarrier2* from,
                                     VkBufferMemoryBarrier2* to);

void deepcopy_VkImageMemoryBarrier2(Allocator* alloc, VkStructureType rootType,
                                    const VkImageMemoryBarrier2* from, VkImageMemoryBarrier2* to);

void deepcopy_VkDependencyInfo(Allocator* alloc, VkStructureType rootType,
                               const VkDependencyInfo* from, VkDependencyInfo* to);

void deepcopy_VkSemaphoreSubmitInfo(Allocator* alloc, VkStructureType rootType,
                                    const VkSemaphoreSubmitInfo* from, VkSemaphoreSubmitInfo* to);

void deepcopy_VkCommandBufferSubmitInfo(Allocator* alloc, VkStructureType rootType,
                                        const VkCommandBufferSubmitInfo* from,
                                        VkCommandBufferSubmitInfo* to);

void deepcopy_VkSubmitInfo2(Allocator* alloc, VkStructureType rootType, const VkSubmitInfo2* from,
                            VkSubmitInfo2* to);

void deepcopy_VkPhysicalDeviceSynchronization2Features(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceSynchronization2Features* from,
    VkPhysicalDeviceSynchronization2Features* to);

void deepcopy_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* from,
    VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* to);

void deepcopy_VkPhysicalDeviceImageRobustnessFeatures(
    Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceImageRobustnessFeatures* from,
    VkPhysicalDeviceImageRobustnessFeatures* to);

void deepcopy_VkBufferCopy2(Allocator* alloc, VkStructureType rootType, const VkBufferCopy2* from,
                            VkBufferCopy2* to);

void deepcopy_VkCopyBufferInfo2(Allocator* alloc, VkStructureType rootType,
                                const VkCopyBufferInfo2* from, VkCopyBufferInfo2* to);

void deepcopy_VkImageCopy2(Allocator* alloc, VkStructureType rootType, const VkImageCopy2* from,
                           VkImageCopy2* to);

void deepcopy_VkCopyImageInfo2(Allocator* alloc, VkStructureType rootType,
                               const VkCopyImageInfo2* from, VkCopyImageInfo2* to);

void deepcopy_VkBufferImageCopy2(Allocator* alloc, VkStructureType rootType,
                                 const VkBufferImageCopy2* from, VkBufferImageCopy2* to);

void deepcopy_VkCopyBufferToImageInfo2(Allocator* alloc, VkStructureType rootType,
                                       const VkCopyBufferToImageInfo2* from,
                                       VkCopyBufferToImageInfo2* to);

void deepcopy_VkCopyImageToBufferInfo2(Allocator* alloc, VkStructureType rootType,
                                       const VkCopyImageToBufferInfo2* from,
                                       VkCopyImageToBufferInfo2* to);

void deepcopy_VkImageBlit2(Allocator* alloc, VkStructureType rootType, const VkImageBlit2* from,
                           VkImageBlit2* to);

void deepcopy_VkBlitImageInfo2(Allocator* alloc, VkStructureType rootType,
                               const VkBlitImageInfo2* from, VkBlitImageInfo2* to);

void deepcopy_VkImageResolve2(Allocator* alloc, VkStructureType rootType,
                              const VkImageResolve2* from, VkImageResolve2* to);

void deepcopy_VkResolveImageInfo2(Allocator* alloc, VkStructureType rootType,
                                  const VkResolveImageInfo2* from, VkResolveImageInfo2* to);

void deepcopy_VkPhysicalDeviceSubgroupSizeControlFeatures(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceSubgroupSizeControlFeatures* from,
    VkPhysicalDeviceSubgroupSizeControlFeatures* to);

void deepcopy_VkPhysicalDeviceSubgroupSizeControlProperties(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceSubgroupSizeControlProperties* from,
    VkPhysicalDeviceSubgroupSizeControlProperties* to);

void deepcopy_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(
    Allocator* alloc, VkStructureType rootType,
    const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo* from,
    VkPipelineShaderStageRequiredSubgroupSizeCreateInfo* to);

void deepcopy_VkPhysicalDeviceInlineUniformBlockFeatures(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceInlineUniformBlockFeatures* from,
    VkPhysicalDeviceInlineUniformBlockFeatures* to);

void deepcopy_VkPhysicalDeviceInlineUniformBlockProperties(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceInlineUniformBlockProperties* from,
    VkPhysicalDeviceInlineUniformBlockProperties* to);

void deepcopy_VkWriteDescriptorSetInlineUniformBlock(
    Allocator* alloc, VkStructureType rootType, const VkWriteDescriptorSetInlineUniformBlock* from,
    VkWriteDescriptorSetInlineUniformBlock* to);

void deepcopy_VkDescriptorPoolInlineUniformBlockCreateInfo(
    Allocator* alloc, VkStructureType rootType,
    const VkDescriptorPoolInlineUniformBlockCreateInfo* from,
    VkDescriptorPoolInlineUniformBlockCreateInfo* to);

void deepcopy_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceTextureCompressionASTCHDRFeatures* from,
    VkPhysicalDeviceTextureCompressionASTCHDRFeatures* to);

void deepcopy_VkRenderingAttachmentInfo(Allocator* alloc, VkStructureType rootType,
                                        const VkRenderingAttachmentInfo* from,
                                        VkRenderingAttachmentInfo* to);

void deepcopy_VkRenderingInfo(Allocator* alloc, VkStructureType rootType,
                              const VkRenderingInfo* from, VkRenderingInfo* to);

void deepcopy_VkPipelineRenderingCreateInfo(Allocator* alloc, VkStructureType rootType,
                                            const VkPipelineRenderingCreateInfo* from,
                                            VkPipelineRenderingCreateInfo* to);

void deepcopy_VkPhysicalDeviceDynamicRenderingFeatures(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceDynamicRenderingFeatures* from,
    VkPhysicalDeviceDynamicRenderingFeatures* to);

void deepcopy_VkCommandBufferInheritanceRenderingInfo(
    Allocator* alloc, VkStructureType rootType, const VkCommandBufferInheritanceRenderingInfo* from,
    VkCommandBufferInheritanceRenderingInfo* to);

void deepcopy_VkPhysicalDeviceShaderIntegerDotProductFeatures(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceShaderIntegerDotProductFeatures* from,
    VkPhysicalDeviceShaderIntegerDotProductFeatures* to);

void deepcopy_VkPhysicalDeviceShaderIntegerDotProductProperties(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceShaderIntegerDotProductProperties* from,
    VkPhysicalDeviceShaderIntegerDotProductProperties* to);

void deepcopy_VkPhysicalDeviceTexelBufferAlignmentProperties(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceTexelBufferAlignmentProperties* from,
    VkPhysicalDeviceTexelBufferAlignmentProperties* to);

void deepcopy_VkFormatProperties3(Allocator* alloc, VkStructureType rootType,
                                  const VkFormatProperties3* from, VkFormatProperties3* to);

void deepcopy_VkPhysicalDeviceMaintenance4Features(Allocator* alloc, VkStructureType rootType,
                                                   const VkPhysicalDeviceMaintenance4Features* from,
                                                   VkPhysicalDeviceMaintenance4Features* to);

void deepcopy_VkPhysicalDeviceMaintenance4Properties(
    Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceMaintenance4Properties* from,
    VkPhysicalDeviceMaintenance4Properties* to);

void deepcopy_VkDeviceBufferMemoryRequirements(Allocator* alloc, VkStructureType rootType,
                                               const VkDeviceBufferMemoryRequirements* from,
                                               VkDeviceBufferMemoryRequirements* to);

void deepcopy_VkDeviceImageMemoryRequirements(Allocator* alloc, VkStructureType rootType,
                                              const VkDeviceImageMemoryRequirements* from,
                                              VkDeviceImageMemoryRequirements* to);

#endif
#ifdef VK_KHR_surface
void deepcopy_VkSurfaceCapabilitiesKHR(Allocator* alloc, VkStructureType rootType,
                                       const VkSurfaceCapabilitiesKHR* from,
                                       VkSurfaceCapabilitiesKHR* to);

void deepcopy_VkSurfaceFormatKHR(Allocator* alloc, VkStructureType rootType,
                                 const VkSurfaceFormatKHR* from, VkSurfaceFormatKHR* to);

#endif
#ifdef VK_KHR_swapchain
void deepcopy_VkSwapchainCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
                                       const VkSwapchainCreateInfoKHR* from,
                                       VkSwapchainCreateInfoKHR* to);

void deepcopy_VkPresentInfoKHR(Allocator* alloc, VkStructureType rootType,
                               const VkPresentInfoKHR* from, VkPresentInfoKHR* to);

void deepcopy_VkImageSwapchainCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
                                            const VkImageSwapchainCreateInfoKHR* from,
                                            VkImageSwapchainCreateInfoKHR* to);

void deepcopy_VkBindImageMemorySwapchainInfoKHR(Allocator* alloc, VkStructureType rootType,
                                                const VkBindImageMemorySwapchainInfoKHR* from,
                                                VkBindImageMemorySwapchainInfoKHR* to);

void deepcopy_VkAcquireNextImageInfoKHR(Allocator* alloc, VkStructureType rootType,
                                        const VkAcquireNextImageInfoKHR* from,
                                        VkAcquireNextImageInfoKHR* to);

void deepcopy_VkDeviceGroupPresentCapabilitiesKHR(Allocator* alloc, VkStructureType rootType,
                                                  const VkDeviceGroupPresentCapabilitiesKHR* from,
                                                  VkDeviceGroupPresentCapabilitiesKHR* to);

void deepcopy_VkDeviceGroupPresentInfoKHR(Allocator* alloc, VkStructureType rootType,
                                          const VkDeviceGroupPresentInfoKHR* from,
                                          VkDeviceGroupPresentInfoKHR* to);

void deepcopy_VkDeviceGroupSwapchainCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
                                                  const VkDeviceGroupSwapchainCreateInfoKHR* from,
                                                  VkDeviceGroupSwapchainCreateInfoKHR* to);

#endif
#ifdef VK_KHR_display
void deepcopy_VkDisplayModeParametersKHR(Allocator* alloc, VkStructureType rootType,
                                         const VkDisplayModeParametersKHR* from,
                                         VkDisplayModeParametersKHR* to);

void deepcopy_VkDisplayModeCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
                                         const VkDisplayModeCreateInfoKHR* from,
                                         VkDisplayModeCreateInfoKHR* to);

void deepcopy_VkDisplayModePropertiesKHR(Allocator* alloc, VkStructureType rootType,
                                         const VkDisplayModePropertiesKHR* from,
                                         VkDisplayModePropertiesKHR* to);

void deepcopy_VkDisplayPlaneCapabilitiesKHR(Allocator* alloc, VkStructureType rootType,
                                            const VkDisplayPlaneCapabilitiesKHR* from,
                                            VkDisplayPlaneCapabilitiesKHR* to);

void deepcopy_VkDisplayPlanePropertiesKHR(Allocator* alloc, VkStructureType rootType,
                                          const VkDisplayPlanePropertiesKHR* from,
                                          VkDisplayPlanePropertiesKHR* to);

void deepcopy_VkDisplayPropertiesKHR(Allocator* alloc, VkStructureType rootType,
                                     const VkDisplayPropertiesKHR* from,
                                     VkDisplayPropertiesKHR* to);

void deepcopy_VkDisplaySurfaceCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
                                            const VkDisplaySurfaceCreateInfoKHR* from,
                                            VkDisplaySurfaceCreateInfoKHR* to);

#endif
#ifdef VK_KHR_display_swapchain
void deepcopy_VkDisplayPresentInfoKHR(Allocator* alloc, VkStructureType rootType,
                                      const VkDisplayPresentInfoKHR* from,
                                      VkDisplayPresentInfoKHR* to);

#endif
#ifdef VK_KHR_xlib_surface
void deepcopy_VkXlibSurfaceCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
                                         const VkXlibSurfaceCreateInfoKHR* from,
                                         VkXlibSurfaceCreateInfoKHR* to);

#endif
#ifdef VK_KHR_xcb_surface
void deepcopy_VkXcbSurfaceCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
                                        const VkXcbSurfaceCreateInfoKHR* from,
                                        VkXcbSurfaceCreateInfoKHR* to);

#endif
#ifdef VK_KHR_wayland_surface
void deepcopy_VkWaylandSurfaceCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
                                            const VkWaylandSurfaceCreateInfoKHR* from,
                                            VkWaylandSurfaceCreateInfoKHR* to);

#endif
#ifdef VK_KHR_android_surface
void deepcopy_VkAndroidSurfaceCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
                                            const VkAndroidSurfaceCreateInfoKHR* from,
                                            VkAndroidSurfaceCreateInfoKHR* to);

#endif
#ifdef VK_KHR_win32_surface
void deepcopy_VkWin32SurfaceCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
                                          const VkWin32SurfaceCreateInfoKHR* from,
                                          VkWin32SurfaceCreateInfoKHR* to);

#endif
#ifdef VK_KHR_sampler_mirror_clamp_to_edge
#endif
#ifdef VK_KHR_video_queue
void deepcopy_VkQueueFamilyQueryResultStatusPropertiesKHR(
    Allocator* alloc, VkStructureType rootType,
    const VkQueueFamilyQueryResultStatusPropertiesKHR* from,
    VkQueueFamilyQueryResultStatusPropertiesKHR* to);

void deepcopy_VkQueueFamilyVideoPropertiesKHR(Allocator* alloc, VkStructureType rootType,
                                              const VkQueueFamilyVideoPropertiesKHR* from,
                                              VkQueueFamilyVideoPropertiesKHR* to);

void deepcopy_VkVideoProfileInfoKHR(Allocator* alloc, VkStructureType rootType,
                                    const VkVideoProfileInfoKHR* from, VkVideoProfileInfoKHR* to);

void deepcopy_VkVideoProfileListInfoKHR(Allocator* alloc, VkStructureType rootType,
                                        const VkVideoProfileListInfoKHR* from,
                                        VkVideoProfileListInfoKHR* to);

void deepcopy_VkVideoCapabilitiesKHR(Allocator* alloc, VkStructureType rootType,
                                     const VkVideoCapabilitiesKHR* from,
                                     VkVideoCapabilitiesKHR* to);

void deepcopy_VkPhysicalDeviceVideoFormatInfoKHR(Allocator* alloc, VkStructureType rootType,
                                                 const VkPhysicalDeviceVideoFormatInfoKHR* from,
                                                 VkPhysicalDeviceVideoFormatInfoKHR* to);

void deepcopy_VkVideoFormatPropertiesKHR(Allocator* alloc, VkStructureType rootType,
                                         const VkVideoFormatPropertiesKHR* from,
                                         VkVideoFormatPropertiesKHR* to);

void deepcopy_VkVideoPictureResourceInfoKHR(Allocator* alloc, VkStructureType rootType,
                                            const VkVideoPictureResourceInfoKHR* from,
                                            VkVideoPictureResourceInfoKHR* to);

void deepcopy_VkVideoReferenceSlotInfoKHR(Allocator* alloc, VkStructureType rootType,
                                          const VkVideoReferenceSlotInfoKHR* from,
                                          VkVideoReferenceSlotInfoKHR* to);

void deepcopy_VkVideoSessionMemoryRequirementsKHR(Allocator* alloc, VkStructureType rootType,
                                                  const VkVideoSessionMemoryRequirementsKHR* from,
                                                  VkVideoSessionMemoryRequirementsKHR* to);

void deepcopy_VkBindVideoSessionMemoryInfoKHR(Allocator* alloc, VkStructureType rootType,
                                              const VkBindVideoSessionMemoryInfoKHR* from,
                                              VkBindVideoSessionMemoryInfoKHR* to);

void deepcopy_VkVideoSessionCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
                                          const VkVideoSessionCreateInfoKHR* from,
                                          VkVideoSessionCreateInfoKHR* to);

void deepcopy_VkVideoSessionParametersCreateInfoKHR(
    Allocator* alloc, VkStructureType rootType, const VkVideoSessionParametersCreateInfoKHR* from,
    VkVideoSessionParametersCreateInfoKHR* to);

void deepcopy_VkVideoSessionParametersUpdateInfoKHR(
    Allocator* alloc, VkStructureType rootType, const VkVideoSessionParametersUpdateInfoKHR* from,
    VkVideoSessionParametersUpdateInfoKHR* to);

void deepcopy_VkVideoBeginCodingInfoKHR(Allocator* alloc, VkStructureType rootType,
                                        const VkVideoBeginCodingInfoKHR* from,
                                        VkVideoBeginCodingInfoKHR* to);

void deepcopy_VkVideoEndCodingInfoKHR(Allocator* alloc, VkStructureType rootType,
                                      const VkVideoEndCodingInfoKHR* from,
                                      VkVideoEndCodingInfoKHR* to);

void deepcopy_VkVideoCodingControlInfoKHR(Allocator* alloc, VkStructureType rootType,
                                          const VkVideoCodingControlInfoKHR* from,
                                          VkVideoCodingControlInfoKHR* to);

#endif
#ifdef VK_KHR_video_decode_queue
void deepcopy_VkVideoDecodeCapabilitiesKHR(Allocator* alloc, VkStructureType rootType,
                                           const VkVideoDecodeCapabilitiesKHR* from,
                                           VkVideoDecodeCapabilitiesKHR* to);

void deepcopy_VkVideoDecodeUsageInfoKHR(Allocator* alloc, VkStructureType rootType,
                                        const VkVideoDecodeUsageInfoKHR* from,
                                        VkVideoDecodeUsageInfoKHR* to);

void deepcopy_VkVideoDecodeInfoKHR(Allocator* alloc, VkStructureType rootType,
                                   const VkVideoDecodeInfoKHR* from, VkVideoDecodeInfoKHR* to);

#endif
#ifdef VK_KHR_video_decode_h264
void deepcopy_VkVideoDecodeH264ProfileInfoKHR(Allocator* alloc, VkStructureType rootType,
                                              const VkVideoDecodeH264ProfileInfoKHR* from,
                                              VkVideoDecodeH264ProfileInfoKHR* to);

void deepcopy_VkVideoDecodeH264CapabilitiesKHR(Allocator* alloc, VkStructureType rootType,
                                               const VkVideoDecodeH264CapabilitiesKHR* from,
                                               VkVideoDecodeH264CapabilitiesKHR* to);

void deepcopy_VkVideoDecodeH264SessionParametersAddInfoKHR(
    Allocator* alloc, VkStructureType rootType,
    const VkVideoDecodeH264SessionParametersAddInfoKHR* from,
    VkVideoDecodeH264SessionParametersAddInfoKHR* to);

void deepcopy_VkVideoDecodeH264SessionParametersCreateInfoKHR(
    Allocator* alloc, VkStructureType rootType,
    const VkVideoDecodeH264SessionParametersCreateInfoKHR* from,
    VkVideoDecodeH264SessionParametersCreateInfoKHR* to);

void deepcopy_VkVideoDecodeH264PictureInfoKHR(Allocator* alloc, VkStructureType rootType,
                                              const VkVideoDecodeH264PictureInfoKHR* from,
                                              VkVideoDecodeH264PictureInfoKHR* to);

void deepcopy_VkVideoDecodeH264DpbSlotInfoKHR(Allocator* alloc, VkStructureType rootType,
                                              const VkVideoDecodeH264DpbSlotInfoKHR* from,
                                              VkVideoDecodeH264DpbSlotInfoKHR* to);

#endif
#ifdef VK_KHR_dynamic_rendering
DEFINE_ALIAS_FUNCTION(deepcopy_VkRenderingInfo, deepcopy_VkRenderingInfoKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkRenderingAttachmentInfo, deepcopy_VkRenderingAttachmentInfoKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkPipelineRenderingCreateInfo,
                      deepcopy_VkPipelineRenderingCreateInfoKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceDynamicRenderingFeatures,
                      deepcopy_VkPhysicalDeviceDynamicRenderingFeaturesKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkCommandBufferInheritanceRenderingInfo,
                      deepcopy_VkCommandBufferInheritanceRenderingInfoKHR)

void deepcopy_VkRenderingFragmentShadingRateAttachmentInfoKHR(
    Allocator* alloc, VkStructureType rootType,
    const VkRenderingFragmentShadingRateAttachmentInfoKHR* from,
    VkRenderingFragmentShadingRateAttachmentInfoKHR* to);

void deepcopy_VkRenderingFragmentDensityMapAttachmentInfoEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkRenderingFragmentDensityMapAttachmentInfoEXT* from,
    VkRenderingFragmentDensityMapAttachmentInfoEXT* to);

void deepcopy_VkAttachmentSampleCountInfoAMD(Allocator* alloc, VkStructureType rootType,
                                             const VkAttachmentSampleCountInfoAMD* from,
                                             VkAttachmentSampleCountInfoAMD* to);

DEFINE_ALIAS_FUNCTION(deepcopy_VkAttachmentSampleCountInfoAMD,
                      deepcopy_VkAttachmentSampleCountInfoNV)

void deepcopy_VkMultiviewPerViewAttributesInfoNVX(Allocator* alloc, VkStructureType rootType,
                                                  const VkMultiviewPerViewAttributesInfoNVX* from,
                                                  VkMultiviewPerViewAttributesInfoNVX* to);

#endif
#ifdef VK_KHR_multiview
DEFINE_ALIAS_FUNCTION(deepcopy_VkRenderPassMultiviewCreateInfo,
                      deepcopy_VkRenderPassMultiviewCreateInfoKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceMultiviewFeatures,
                      deepcopy_VkPhysicalDeviceMultiviewFeaturesKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceMultiviewProperties,
                      deepcopy_VkPhysicalDeviceMultiviewPropertiesKHR)

#endif
#ifdef VK_KHR_get_physical_device_properties2
DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceFeatures2, deepcopy_VkPhysicalDeviceFeatures2KHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceProperties2, deepcopy_VkPhysicalDeviceProperties2KHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkFormatProperties2, deepcopy_VkFormatProperties2KHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkImageFormatProperties2, deepcopy_VkImageFormatProperties2KHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceImageFormatInfo2,
                      deepcopy_VkPhysicalDeviceImageFormatInfo2KHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkQueueFamilyProperties2, deepcopy_VkQueueFamilyProperties2KHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceMemoryProperties2,
                      deepcopy_VkPhysicalDeviceMemoryProperties2KHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkSparseImageFormatProperties2,
                      deepcopy_VkSparseImageFormatProperties2KHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceSparseImageFormatInfo2,
                      deepcopy_VkPhysicalDeviceSparseImageFormatInfo2KHR)

#endif
#ifdef VK_KHR_device_group
DEFINE_ALIAS_FUNCTION(deepcopy_VkMemoryAllocateFlagsInfo, deepcopy_VkMemoryAllocateFlagsInfoKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkDeviceGroupRenderPassBeginInfo,
                      deepcopy_VkDeviceGroupRenderPassBeginInfoKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkDeviceGroupCommandBufferBeginInfo,
                      deepcopy_VkDeviceGroupCommandBufferBeginInfoKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkDeviceGroupSubmitInfo, deepcopy_VkDeviceGroupSubmitInfoKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkDeviceGroupBindSparseInfo, deepcopy_VkDeviceGroupBindSparseInfoKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkBindBufferMemoryDeviceGroupInfo,
                      deepcopy_VkBindBufferMemoryDeviceGroupInfoKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkBindImageMemoryDeviceGroupInfo,
                      deepcopy_VkBindImageMemoryDeviceGroupInfoKHR)

#endif
#ifdef VK_KHR_shader_draw_parameters
#endif
#ifdef VK_KHR_maintenance1
#endif
#ifdef VK_KHR_device_group_creation
DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceGroupProperties,
                      deepcopy_VkPhysicalDeviceGroupPropertiesKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkDeviceGroupDeviceCreateInfo,
                      deepcopy_VkDeviceGroupDeviceCreateInfoKHR)

#endif
#ifdef VK_KHR_external_memory_capabilities
DEFINE_ALIAS_FUNCTION(deepcopy_VkExternalMemoryProperties, deepcopy_VkExternalMemoryPropertiesKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceExternalImageFormatInfo,
                      deepcopy_VkPhysicalDeviceExternalImageFormatInfoKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkExternalImageFormatProperties,
                      deepcopy_VkExternalImageFormatPropertiesKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceExternalBufferInfo,
                      deepcopy_VkPhysicalDeviceExternalBufferInfoKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkExternalBufferProperties, deepcopy_VkExternalBufferPropertiesKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceIDProperties,
                      deepcopy_VkPhysicalDeviceIDPropertiesKHR)

#endif
#ifdef VK_KHR_external_memory
DEFINE_ALIAS_FUNCTION(deepcopy_VkExternalMemoryImageCreateInfo,
                      deepcopy_VkExternalMemoryImageCreateInfoKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkExternalMemoryBufferCreateInfo,
                      deepcopy_VkExternalMemoryBufferCreateInfoKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkExportMemoryAllocateInfo, deepcopy_VkExportMemoryAllocateInfoKHR)

#endif
#ifdef VK_KHR_external_memory_win32
void deepcopy_VkImportMemoryWin32HandleInfoKHR(Allocator* alloc, VkStructureType rootType,
                                               const VkImportMemoryWin32HandleInfoKHR* from,
                                               VkImportMemoryWin32HandleInfoKHR* to);

void deepcopy_VkExportMemoryWin32HandleInfoKHR(Allocator* alloc, VkStructureType rootType,
                                               const VkExportMemoryWin32HandleInfoKHR* from,
                                               VkExportMemoryWin32HandleInfoKHR* to);

void deepcopy_VkMemoryWin32HandlePropertiesKHR(Allocator* alloc, VkStructureType rootType,
                                               const VkMemoryWin32HandlePropertiesKHR* from,
                                               VkMemoryWin32HandlePropertiesKHR* to);

void deepcopy_VkMemoryGetWin32HandleInfoKHR(Allocator* alloc, VkStructureType rootType,
                                            const VkMemoryGetWin32HandleInfoKHR* from,
                                            VkMemoryGetWin32HandleInfoKHR* to);

#endif
#ifdef VK_KHR_external_memory_fd
void deepcopy_VkImportMemoryFdInfoKHR(Allocator* alloc, VkStructureType rootType,
                                      const VkImportMemoryFdInfoKHR* from,
                                      VkImportMemoryFdInfoKHR* to);

void deepcopy_VkMemoryFdPropertiesKHR(Allocator* alloc, VkStructureType rootType,
                                      const VkMemoryFdPropertiesKHR* from,
                                      VkMemoryFdPropertiesKHR* to);

void deepcopy_VkMemoryGetFdInfoKHR(Allocator* alloc, VkStructureType rootType,
                                   const VkMemoryGetFdInfoKHR* from, VkMemoryGetFdInfoKHR* to);

#endif
#ifdef VK_KHR_win32_keyed_mutex
void deepcopy_VkWin32KeyedMutexAcquireReleaseInfoKHR(
    Allocator* alloc, VkStructureType rootType, const VkWin32KeyedMutexAcquireReleaseInfoKHR* from,
    VkWin32KeyedMutexAcquireReleaseInfoKHR* to);

#endif
#ifdef VK_KHR_external_semaphore_capabilities
DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceExternalSemaphoreInfo,
                      deepcopy_VkPhysicalDeviceExternalSemaphoreInfoKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkExternalSemaphoreProperties,
                      deepcopy_VkExternalSemaphorePropertiesKHR)

#endif
#ifdef VK_KHR_external_semaphore
DEFINE_ALIAS_FUNCTION(deepcopy_VkExportSemaphoreCreateInfo, deepcopy_VkExportSemaphoreCreateInfoKHR)

#endif
#ifdef VK_KHR_external_semaphore_win32
void deepcopy_VkImportSemaphoreWin32HandleInfoKHR(Allocator* alloc, VkStructureType rootType,
                                                  const VkImportSemaphoreWin32HandleInfoKHR* from,
                                                  VkImportSemaphoreWin32HandleInfoKHR* to);

void deepcopy_VkExportSemaphoreWin32HandleInfoKHR(Allocator* alloc, VkStructureType rootType,
                                                  const VkExportSemaphoreWin32HandleInfoKHR* from,
                                                  VkExportSemaphoreWin32HandleInfoKHR* to);

void deepcopy_VkD3D12FenceSubmitInfoKHR(Allocator* alloc, VkStructureType rootType,
                                        const VkD3D12FenceSubmitInfoKHR* from,
                                        VkD3D12FenceSubmitInfoKHR* to);

void deepcopy_VkSemaphoreGetWin32HandleInfoKHR(Allocator* alloc, VkStructureType rootType,
                                               const VkSemaphoreGetWin32HandleInfoKHR* from,
                                               VkSemaphoreGetWin32HandleInfoKHR* to);

#endif
#ifdef VK_KHR_external_semaphore_fd
void deepcopy_VkImportSemaphoreFdInfoKHR(Allocator* alloc, VkStructureType rootType,
                                         const VkImportSemaphoreFdInfoKHR* from,
                                         VkImportSemaphoreFdInfoKHR* to);

void deepcopy_VkSemaphoreGetFdInfoKHR(Allocator* alloc, VkStructureType rootType,
                                      const VkSemaphoreGetFdInfoKHR* from,
                                      VkSemaphoreGetFdInfoKHR* to);

#endif
#ifdef VK_KHR_push_descriptor
void deepcopy_VkPhysicalDevicePushDescriptorPropertiesKHR(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDevicePushDescriptorPropertiesKHR* from,
    VkPhysicalDevicePushDescriptorPropertiesKHR* to);

#endif
#ifdef VK_KHR_shader_float16_int8
DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceShaderFloat16Int8Features,
                      deepcopy_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceShaderFloat16Int8Features,
                      deepcopy_VkPhysicalDeviceFloat16Int8FeaturesKHR)

#endif
#ifdef VK_KHR_16bit_storage
DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDevice16BitStorageFeatures,
                      deepcopy_VkPhysicalDevice16BitStorageFeaturesKHR)

#endif
#ifdef VK_KHR_incremental_present
void deepcopy_VkRectLayerKHR(Allocator* alloc, VkStructureType rootType, const VkRectLayerKHR* from,
                             VkRectLayerKHR* to);

void deepcopy_VkPresentRegionKHR(Allocator* alloc, VkStructureType rootType,
                                 const VkPresentRegionKHR* from, VkPresentRegionKHR* to);

void deepcopy_VkPresentRegionsKHR(Allocator* alloc, VkStructureType rootType,
                                  const VkPresentRegionsKHR* from, VkPresentRegionsKHR* to);

#endif
#ifdef VK_KHR_descriptor_update_template
DEFINE_ALIAS_FUNCTION(deepcopy_VkDescriptorUpdateTemplateEntry,
                      deepcopy_VkDescriptorUpdateTemplateEntryKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkDescriptorUpdateTemplateCreateInfo,
                      deepcopy_VkDescriptorUpdateTemplateCreateInfoKHR)

#endif
#ifdef VK_KHR_imageless_framebuffer
DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceImagelessFramebufferFeatures,
                      deepcopy_VkPhysicalDeviceImagelessFramebufferFeaturesKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkFramebufferAttachmentsCreateInfo,
                      deepcopy_VkFramebufferAttachmentsCreateInfoKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkFramebufferAttachmentImageInfo,
                      deepcopy_VkFramebufferAttachmentImageInfoKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkRenderPassAttachmentBeginInfo,
                      deepcopy_VkRenderPassAttachmentBeginInfoKHR)

#endif
#ifdef VK_KHR_create_renderpass2
DEFINE_ALIAS_FUNCTION(deepcopy_VkRenderPassCreateInfo2, deepcopy_VkRenderPassCreateInfo2KHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkAttachmentDescription2, deepcopy_VkAttachmentDescription2KHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkAttachmentReference2, deepcopy_VkAttachmentReference2KHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkSubpassDescription2, deepcopy_VkSubpassDescription2KHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkSubpassDependency2, deepcopy_VkSubpassDependency2KHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkSubpassBeginInfo, deepcopy_VkSubpassBeginInfoKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkSubpassEndInfo, deepcopy_VkSubpassEndInfoKHR)

#endif
#ifdef VK_KHR_shared_presentable_image
void deepcopy_VkSharedPresentSurfaceCapabilitiesKHR(
    Allocator* alloc, VkStructureType rootType, const VkSharedPresentSurfaceCapabilitiesKHR* from,
    VkSharedPresentSurfaceCapabilitiesKHR* to);

#endif
#ifdef VK_KHR_external_fence_capabilities
DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceExternalFenceInfo,
                      deepcopy_VkPhysicalDeviceExternalFenceInfoKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkExternalFenceProperties, deepcopy_VkExternalFencePropertiesKHR)

#endif
#ifdef VK_KHR_external_fence
DEFINE_ALIAS_FUNCTION(deepcopy_VkExportFenceCreateInfo, deepcopy_VkExportFenceCreateInfoKHR)

#endif
#ifdef VK_KHR_external_fence_win32
void deepcopy_VkImportFenceWin32HandleInfoKHR(Allocator* alloc, VkStructureType rootType,
                                              const VkImportFenceWin32HandleInfoKHR* from,
                                              VkImportFenceWin32HandleInfoKHR* to);

void deepcopy_VkExportFenceWin32HandleInfoKHR(Allocator* alloc, VkStructureType rootType,
                                              const VkExportFenceWin32HandleInfoKHR* from,
                                              VkExportFenceWin32HandleInfoKHR* to);

void deepcopy_VkFenceGetWin32HandleInfoKHR(Allocator* alloc, VkStructureType rootType,
                                           const VkFenceGetWin32HandleInfoKHR* from,
                                           VkFenceGetWin32HandleInfoKHR* to);

#endif
#ifdef VK_KHR_external_fence_fd
void deepcopy_VkImportFenceFdInfoKHR(Allocator* alloc, VkStructureType rootType,
                                     const VkImportFenceFdInfoKHR* from,
                                     VkImportFenceFdInfoKHR* to);

void deepcopy_VkFenceGetFdInfoKHR(Allocator* alloc, VkStructureType rootType,
                                  const VkFenceGetFdInfoKHR* from, VkFenceGetFdInfoKHR* to);

#endif
#ifdef VK_KHR_performance_query
void deepcopy_VkPhysicalDevicePerformanceQueryFeaturesKHR(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDevicePerformanceQueryFeaturesKHR* from,
    VkPhysicalDevicePerformanceQueryFeaturesKHR* to);

void deepcopy_VkPhysicalDevicePerformanceQueryPropertiesKHR(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDevicePerformanceQueryPropertiesKHR* from,
    VkPhysicalDevicePerformanceQueryPropertiesKHR* to);

void deepcopy_VkPerformanceCounterKHR(Allocator* alloc, VkStructureType rootType,
                                      const VkPerformanceCounterKHR* from,
                                      VkPerformanceCounterKHR* to);

void deepcopy_VkPerformanceCounterDescriptionKHR(Allocator* alloc, VkStructureType rootType,
                                                 const VkPerformanceCounterDescriptionKHR* from,
                                                 VkPerformanceCounterDescriptionKHR* to);

void deepcopy_VkQueryPoolPerformanceCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
                                                  const VkQueryPoolPerformanceCreateInfoKHR* from,
                                                  VkQueryPoolPerformanceCreateInfoKHR* to);

void deepcopy_VkPerformanceCounterResultKHR(Allocator* alloc, VkStructureType rootType,
                                            const VkPerformanceCounterResultKHR* from,
                                            VkPerformanceCounterResultKHR* to);

void deepcopy_VkAcquireProfilingLockInfoKHR(Allocator* alloc, VkStructureType rootType,
                                            const VkAcquireProfilingLockInfoKHR* from,
                                            VkAcquireProfilingLockInfoKHR* to);

void deepcopy_VkPerformanceQuerySubmitInfoKHR(Allocator* alloc, VkStructureType rootType,
                                              const VkPerformanceQuerySubmitInfoKHR* from,
                                              VkPerformanceQuerySubmitInfoKHR* to);

#endif
#ifdef VK_KHR_maintenance2
DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDevicePointClippingProperties,
                      deepcopy_VkPhysicalDevicePointClippingPropertiesKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkRenderPassInputAttachmentAspectCreateInfo,
                      deepcopy_VkRenderPassInputAttachmentAspectCreateInfoKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkInputAttachmentAspectReference,
                      deepcopy_VkInputAttachmentAspectReferenceKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkImageViewUsageCreateInfo, deepcopy_VkImageViewUsageCreateInfoKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkPipelineTessellationDomainOriginStateCreateInfo,
                      deepcopy_VkPipelineTessellationDomainOriginStateCreateInfoKHR)

#endif
#ifdef VK_KHR_get_surface_capabilities2
void deepcopy_VkPhysicalDeviceSurfaceInfo2KHR(Allocator* alloc, VkStructureType rootType,
                                              const VkPhysicalDeviceSurfaceInfo2KHR* from,
                                              VkPhysicalDeviceSurfaceInfo2KHR* to);

void deepcopy_VkSurfaceCapabilities2KHR(Allocator* alloc, VkStructureType rootType,
                                        const VkSurfaceCapabilities2KHR* from,
                                        VkSurfaceCapabilities2KHR* to);

void deepcopy_VkSurfaceFormat2KHR(Allocator* alloc, VkStructureType rootType,
                                  const VkSurfaceFormat2KHR* from, VkSurfaceFormat2KHR* to);

#endif
#ifdef VK_KHR_variable_pointers
DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceVariablePointersFeatures,
                      deepcopy_VkPhysicalDeviceVariablePointerFeaturesKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceVariablePointersFeatures,
                      deepcopy_VkPhysicalDeviceVariablePointersFeaturesKHR)

#endif
#ifdef VK_KHR_get_display_properties2
void deepcopy_VkDisplayProperties2KHR(Allocator* alloc, VkStructureType rootType,
                                      const VkDisplayProperties2KHR* from,
                                      VkDisplayProperties2KHR* to);

void deepcopy_VkDisplayPlaneProperties2KHR(Allocator* alloc, VkStructureType rootType,
                                           const VkDisplayPlaneProperties2KHR* from,
                                           VkDisplayPlaneProperties2KHR* to);

void deepcopy_VkDisplayModeProperties2KHR(Allocator* alloc, VkStructureType rootType,
                                          const VkDisplayModeProperties2KHR* from,
                                          VkDisplayModeProperties2KHR* to);

void deepcopy_VkDisplayPlaneInfo2KHR(Allocator* alloc, VkStructureType rootType,
                                     const VkDisplayPlaneInfo2KHR* from,
                                     VkDisplayPlaneInfo2KHR* to);

void deepcopy_VkDisplayPlaneCapabilities2KHR(Allocator* alloc, VkStructureType rootType,
                                             const VkDisplayPlaneCapabilities2KHR* from,
                                             VkDisplayPlaneCapabilities2KHR* to);

#endif
#ifdef VK_KHR_dedicated_allocation
DEFINE_ALIAS_FUNCTION(deepcopy_VkMemoryDedicatedRequirements,
                      deepcopy_VkMemoryDedicatedRequirementsKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkMemoryDedicatedAllocateInfo,
                      deepcopy_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(deepcopy_VkBufferMemoryRequirementsInfo2,
                      deepcopy_VkBufferMemoryRequirementsInfo2KHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkImageMemoryRequirementsInfo2,
                      deepcopy_VkImageMemoryRequirementsInfo2KHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkImageSparseMemoryRequirementsInfo2,
                      deepcopy_VkImageSparseMemoryRequirementsInfo2KHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkMemoryRequirements2, deepcopy_VkMemoryRequirements2KHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkSparseImageMemoryRequirements2,
                      deepcopy_VkSparseImageMemoryRequirements2KHR)

#endif
#ifdef VK_KHR_image_format_list
DEFINE_ALIAS_FUNCTION(deepcopy_VkImageFormatListCreateInfo, deepcopy_VkImageFormatListCreateInfoKHR)

#endif
#ifdef VK_KHR_sampler_ycbcr_conversion
DEFINE_ALIAS_FUNCTION(deepcopy_VkSamplerYcbcrConversionCreateInfo,
                      deepcopy_VkSamplerYcbcrConversionCreateInfoKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkSamplerYcbcrConversionInfo,
                      deepcopy_VkSamplerYcbcrConversionInfoKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkBindImagePlaneMemoryInfo, deepcopy_VkBindImagePlaneMemoryInfoKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkImagePlaneMemoryRequirementsInfo,
                      deepcopy_VkImagePlaneMemoryRequirementsInfoKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceSamplerYcbcrConversionFeatures,
                      deepcopy_VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkSamplerYcbcrConversionImageFormatProperties,
                      deepcopy_VkSamplerYcbcrConversionImageFormatPropertiesKHR)

#endif
#ifdef VK_KHR_bind_memory2
DEFINE_ALIAS_FUNCTION(deepcopy_VkBindBufferMemoryInfo, deepcopy_VkBindBufferMemoryInfoKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkBindImageMemoryInfo, deepcopy_VkBindImageMemoryInfoKHR)

#endif
#ifdef VK_KHR_portability_subset
void deepcopy_VkPhysicalDevicePortabilitySubsetFeaturesKHR(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDevicePortabilitySubsetFeaturesKHR* from,
    VkPhysicalDevicePortabilitySubsetFeaturesKHR* to);

void deepcopy_VkPhysicalDevicePortabilitySubsetPropertiesKHR(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDevicePortabilitySubsetPropertiesKHR* from,
    VkPhysicalDevicePortabilitySubsetPropertiesKHR* to);

#endif
#ifdef VK_KHR_maintenance3
DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceMaintenance3Properties,
                      deepcopy_VkPhysicalDeviceMaintenance3PropertiesKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkDescriptorSetLayoutSupport,
                      deepcopy_VkDescriptorSetLayoutSupportKHR)

#endif
#ifdef VK_KHR_draw_indirect_count
#endif
#ifdef VK_KHR_shader_subgroup_extended_types
DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures,
                      deepcopy_VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR)

#endif
#ifdef VK_KHR_8bit_storage
DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDevice8BitStorageFeatures,
                      deepcopy_VkPhysicalDevice8BitStorageFeaturesKHR)

#endif
#ifdef VK_KHR_shader_atomic_int64
DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceShaderAtomicInt64Features,
                      deepcopy_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR)

#endif
#ifdef VK_KHR_shader_clock
void deepcopy_VkPhysicalDeviceShaderClockFeaturesKHR(
    Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceShaderClockFeaturesKHR* from,
    VkPhysicalDeviceShaderClockFeaturesKHR* to);

#endif
#ifdef VK_KHR_video_decode_h265
void deepcopy_VkVideoDecodeH265ProfileInfoKHR(Allocator* alloc, VkStructureType rootType,
                                              const VkVideoDecodeH265ProfileInfoKHR* from,
                                              VkVideoDecodeH265ProfileInfoKHR* to);

void deepcopy_VkVideoDecodeH265CapabilitiesKHR(Allocator* alloc, VkStructureType rootType,
                                               const VkVideoDecodeH265CapabilitiesKHR* from,
                                               VkVideoDecodeH265CapabilitiesKHR* to);

void deepcopy_VkVideoDecodeH265SessionParametersAddInfoKHR(
    Allocator* alloc, VkStructureType rootType,
    const VkVideoDecodeH265SessionParametersAddInfoKHR* from,
    VkVideoDecodeH265SessionParametersAddInfoKHR* to);

void deepcopy_VkVideoDecodeH265SessionParametersCreateInfoKHR(
    Allocator* alloc, VkStructureType rootType,
    const VkVideoDecodeH265SessionParametersCreateInfoKHR* from,
    VkVideoDecodeH265SessionParametersCreateInfoKHR* to);

void deepcopy_VkVideoDecodeH265PictureInfoKHR(Allocator* alloc, VkStructureType rootType,
                                              const VkVideoDecodeH265PictureInfoKHR* from,
                                              VkVideoDecodeH265PictureInfoKHR* to);

void deepcopy_VkVideoDecodeH265DpbSlotInfoKHR(Allocator* alloc, VkStructureType rootType,
                                              const VkVideoDecodeH265DpbSlotInfoKHR* from,
                                              VkVideoDecodeH265DpbSlotInfoKHR* to);

#endif
#ifdef VK_KHR_global_priority
void deepcopy_VkDeviceQueueGlobalPriorityCreateInfoKHR(
    Allocator* alloc, VkStructureType rootType,
    const VkDeviceQueueGlobalPriorityCreateInfoKHR* from,
    VkDeviceQueueGlobalPriorityCreateInfoKHR* to);

void deepcopy_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* from,
    VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* to);

void deepcopy_VkQueueFamilyGlobalPriorityPropertiesKHR(
    Allocator* alloc, VkStructureType rootType,
    const VkQueueFamilyGlobalPriorityPropertiesKHR* from,
    VkQueueFamilyGlobalPriorityPropertiesKHR* to);

#endif
#ifdef VK_KHR_driver_properties
DEFINE_ALIAS_FUNCTION(deepcopy_VkConformanceVersion, deepcopy_VkConformanceVersionKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceDriverProperties,
                      deepcopy_VkPhysicalDeviceDriverPropertiesKHR)

#endif
#ifdef VK_KHR_shader_float_controls
DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceFloatControlsProperties,
                      deepcopy_VkPhysicalDeviceFloatControlsPropertiesKHR)

#endif
#ifdef VK_KHR_depth_stencil_resolve
DEFINE_ALIAS_FUNCTION(deepcopy_VkSubpassDescriptionDepthStencilResolve,
                      deepcopy_VkSubpassDescriptionDepthStencilResolveKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceDepthStencilResolveProperties,
                      deepcopy_VkPhysicalDeviceDepthStencilResolvePropertiesKHR)

#endif
#ifdef VK_KHR_swapchain_mutable_format
#endif
#ifdef VK_KHR_timeline_semaphore
DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceTimelineSemaphoreFeatures,
                      deepcopy_VkPhysicalDeviceTimelineSemaphoreFeaturesKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceTimelineSemaphoreProperties,
                      deepcopy_VkPhysicalDeviceTimelineSemaphorePropertiesKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkSemaphoreTypeCreateInfo, deepcopy_VkSemaphoreTypeCreateInfoKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkTimelineSemaphoreSubmitInfo,
                      deepcopy_VkTimelineSemaphoreSubmitInfoKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkSemaphoreWaitInfo, deepcopy_VkSemaphoreWaitInfoKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkSemaphoreSignalInfo, deepcopy_VkSemaphoreSignalInfoKHR)

#endif
#ifdef VK_KHR_vulkan_memory_model
DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceVulkanMemoryModelFeatures,
                      deepcopy_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR)

#endif
#ifdef VK_KHR_shader_terminate_invocation
DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceShaderTerminateInvocationFeatures,
                      deepcopy_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR)

#endif
#ifdef VK_KHR_fragment_shading_rate
void deepcopy_VkFragmentShadingRateAttachmentInfoKHR(
    Allocator* alloc, VkStructureType rootType, const VkFragmentShadingRateAttachmentInfoKHR* from,
    VkFragmentShadingRateAttachmentInfoKHR* to);

void deepcopy_VkPipelineFragmentShadingRateStateCreateInfoKHR(
    Allocator* alloc, VkStructureType rootType,
    const VkPipelineFragmentShadingRateStateCreateInfoKHR* from,
    VkPipelineFragmentShadingRateStateCreateInfoKHR* to);

void deepcopy_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceFragmentShadingRateFeaturesKHR* from,
    VkPhysicalDeviceFragmentShadingRateFeaturesKHR* to);

void deepcopy_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceFragmentShadingRatePropertiesKHR* from,
    VkPhysicalDeviceFragmentShadingRatePropertiesKHR* to);

void deepcopy_VkPhysicalDeviceFragmentShadingRateKHR(
    Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceFragmentShadingRateKHR* from,
    VkPhysicalDeviceFragmentShadingRateKHR* to);

#endif
#ifdef VK_KHR_spirv_1_4
#endif
#ifdef VK_KHR_surface_protected_capabilities
void deepcopy_VkSurfaceProtectedCapabilitiesKHR(Allocator* alloc, VkStructureType rootType,
                                                const VkSurfaceProtectedCapabilitiesKHR* from,
                                                VkSurfaceProtectedCapabilitiesKHR* to);

#endif
#ifdef VK_KHR_separate_depth_stencil_layouts
DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures,
                      deepcopy_VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkAttachmentReferenceStencilLayout,
                      deepcopy_VkAttachmentReferenceStencilLayoutKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkAttachmentDescriptionStencilLayout,
                      deepcopy_VkAttachmentDescriptionStencilLayoutKHR)

#endif
#ifdef VK_KHR_present_wait
void deepcopy_VkPhysicalDevicePresentWaitFeaturesKHR(
    Allocator* alloc, VkStructureType rootType, const VkPhysicalDevicePresentWaitFeaturesKHR* from,
    VkPhysicalDevicePresentWaitFeaturesKHR* to);

#endif
#ifdef VK_KHR_uniform_buffer_standard_layout
DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceUniformBufferStandardLayoutFeatures,
                      deepcopy_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR)

#endif
#ifdef VK_KHR_buffer_device_address
DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceBufferDeviceAddressFeatures,
                      deepcopy_VkPhysicalDeviceBufferDeviceAddressFeaturesKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkBufferDeviceAddressInfo, deepcopy_VkBufferDeviceAddressInfoKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkBufferOpaqueCaptureAddressCreateInfo,
                      deepcopy_VkBufferOpaqueCaptureAddressCreateInfoKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkMemoryOpaqueCaptureAddressAllocateInfo,
                      deepcopy_VkMemoryOpaqueCaptureAddressAllocateInfoKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkDeviceMemoryOpaqueCaptureAddressInfo,
                      deepcopy_VkDeviceMemoryOpaqueCaptureAddressInfoKHR)

#endif
#ifdef VK_KHR_deferred_host_operations
#endif
#ifdef VK_KHR_pipeline_executable_properties
void deepcopy_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* from,
    VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* to);

void deepcopy_VkPipelineInfoKHR(Allocator* alloc, VkStructureType rootType,
                                const VkPipelineInfoKHR* from, VkPipelineInfoKHR* to);

void deepcopy_VkPipelineExecutablePropertiesKHR(Allocator* alloc, VkStructureType rootType,
                                                const VkPipelineExecutablePropertiesKHR* from,
                                                VkPipelineExecutablePropertiesKHR* to);

void deepcopy_VkPipelineExecutableInfoKHR(Allocator* alloc, VkStructureType rootType,
                                          const VkPipelineExecutableInfoKHR* from,
                                          VkPipelineExecutableInfoKHR* to);

void deepcopy_VkPipelineExecutableStatisticValueKHR(
    Allocator* alloc, VkStructureType rootType, const VkPipelineExecutableStatisticValueKHR* from,
    VkPipelineExecutableStatisticValueKHR* to);

void deepcopy_VkPipelineExecutableStatisticKHR(Allocator* alloc, VkStructureType rootType,
                                               const VkPipelineExecutableStatisticKHR* from,
                                               VkPipelineExecutableStatisticKHR* to);

void deepcopy_VkPipelineExecutableInternalRepresentationKHR(
    Allocator* alloc, VkStructureType rootType,
    const VkPipelineExecutableInternalRepresentationKHR* from,
    VkPipelineExecutableInternalRepresentationKHR* to);

#endif
#ifdef VK_KHR_map_memory2
void deepcopy_VkMemoryMapInfoKHR(Allocator* alloc, VkStructureType rootType,
                                 const VkMemoryMapInfoKHR* from, VkMemoryMapInfoKHR* to);

void deepcopy_VkMemoryUnmapInfoKHR(Allocator* alloc, VkStructureType rootType,
                                   const VkMemoryUnmapInfoKHR* from, VkMemoryUnmapInfoKHR* to);

#endif
#ifdef VK_KHR_shader_integer_dot_product
DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceShaderIntegerDotProductFeatures,
                      deepcopy_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceShaderIntegerDotProductProperties,
                      deepcopy_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR)

#endif
#ifdef VK_KHR_pipeline_library
void deepcopy_VkPipelineLibraryCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
                                             const VkPipelineLibraryCreateInfoKHR* from,
                                             VkPipelineLibraryCreateInfoKHR* to);

#endif
#ifdef VK_KHR_shader_non_semantic_info
#endif
#ifdef VK_KHR_present_id
void deepcopy_VkPresentIdKHR(Allocator* alloc, VkStructureType rootType, const VkPresentIdKHR* from,
                             VkPresentIdKHR* to);

void deepcopy_VkPhysicalDevicePresentIdFeaturesKHR(Allocator* alloc, VkStructureType rootType,
                                                   const VkPhysicalDevicePresentIdFeaturesKHR* from,
                                                   VkPhysicalDevicePresentIdFeaturesKHR* to);

#endif
#ifdef VK_KHR_video_encode_queue
void deepcopy_VkVideoEncodeInfoKHR(Allocator* alloc, VkStructureType rootType,
                                   const VkVideoEncodeInfoKHR* from, VkVideoEncodeInfoKHR* to);

void deepcopy_VkVideoEncodeCapabilitiesKHR(Allocator* alloc, VkStructureType rootType,
                                           const VkVideoEncodeCapabilitiesKHR* from,
                                           VkVideoEncodeCapabilitiesKHR* to);

void deepcopy_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR(
    Allocator* alloc, VkStructureType rootType,
    const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* from,
    VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* to);

void deepcopy_VkVideoEncodeUsageInfoKHR(Allocator* alloc, VkStructureType rootType,
                                        const VkVideoEncodeUsageInfoKHR* from,
                                        VkVideoEncodeUsageInfoKHR* to);

void deepcopy_VkVideoEncodeRateControlLayerInfoKHR(Allocator* alloc, VkStructureType rootType,
                                                   const VkVideoEncodeRateControlLayerInfoKHR* from,
                                                   VkVideoEncodeRateControlLayerInfoKHR* to);

void deepcopy_VkVideoEncodeRateControlInfoKHR(Allocator* alloc, VkStructureType rootType,
                                              const VkVideoEncodeRateControlInfoKHR* from,
                                              VkVideoEncodeRateControlInfoKHR* to);

#endif
#ifdef VK_KHR_synchronization2
DEFINE_ALIAS_FUNCTION(deepcopy_VkMemoryBarrier2, deepcopy_VkMemoryBarrier2KHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkBufferMemoryBarrier2, deepcopy_VkBufferMemoryBarrier2KHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkImageMemoryBarrier2, deepcopy_VkImageMemoryBarrier2KHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkDependencyInfo, deepcopy_VkDependencyInfoKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkSubmitInfo2, deepcopy_VkSubmitInfo2KHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkSemaphoreSubmitInfo, deepcopy_VkSemaphoreSubmitInfoKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkCommandBufferSubmitInfo, deepcopy_VkCommandBufferSubmitInfoKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceSynchronization2Features,
                      deepcopy_VkPhysicalDeviceSynchronization2FeaturesKHR)

void deepcopy_VkQueueFamilyCheckpointProperties2NV(Allocator* alloc, VkStructureType rootType,
                                                   const VkQueueFamilyCheckpointProperties2NV* from,
                                                   VkQueueFamilyCheckpointProperties2NV* to);

void deepcopy_VkCheckpointData2NV(Allocator* alloc, VkStructureType rootType,
                                  const VkCheckpointData2NV* from, VkCheckpointData2NV* to);

#endif
#ifdef VK_KHR_fragment_shader_barycentric
void deepcopy_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* from,
    VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* to);

void deepcopy_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* from,
    VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* to);

#endif
#ifdef VK_KHR_shader_subgroup_uniform_control_flow
void deepcopy_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* from,
    VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* to);

#endif
#ifdef VK_KHR_zero_initialize_workgroup_memory
DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures,
                      deepcopy_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR)

#endif
#ifdef VK_KHR_workgroup_memory_explicit_layout
void deepcopy_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* from,
    VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* to);

#endif
#ifdef VK_KHR_copy_commands2
DEFINE_ALIAS_FUNCTION(deepcopy_VkCopyBufferInfo2, deepcopy_VkCopyBufferInfo2KHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkCopyImageInfo2, deepcopy_VkCopyImageInfo2KHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkCopyBufferToImageInfo2, deepcopy_VkCopyBufferToImageInfo2KHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkCopyImageToBufferInfo2, deepcopy_VkCopyImageToBufferInfo2KHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkBlitImageInfo2, deepcopy_VkBlitImageInfo2KHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkResolveImageInfo2, deepcopy_VkResolveImageInfo2KHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkBufferCopy2, deepcopy_VkBufferCopy2KHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkImageCopy2, deepcopy_VkImageCopy2KHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkImageBlit2, deepcopy_VkImageBlit2KHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkBufferImageCopy2, deepcopy_VkBufferImageCopy2KHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkImageResolve2, deepcopy_VkImageResolve2KHR)

#endif
#ifdef VK_KHR_format_feature_flags2
DEFINE_ALIAS_FUNCTION(deepcopy_VkFormatProperties3, deepcopy_VkFormatProperties3KHR)

#endif
#ifdef VK_KHR_ray_tracing_maintenance1
void deepcopy_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* from,
    VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* to);

void deepcopy_VkTraceRaysIndirectCommand2KHR(Allocator* alloc, VkStructureType rootType,
                                             const VkTraceRaysIndirectCommand2KHR* from,
                                             VkTraceRaysIndirectCommand2KHR* to);

#endif
#ifdef VK_KHR_portability_enumeration
#endif
#ifdef VK_KHR_maintenance4
DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceMaintenance4Features,
                      deepcopy_VkPhysicalDeviceMaintenance4FeaturesKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceMaintenance4Properties,
                      deepcopy_VkPhysicalDeviceMaintenance4PropertiesKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkDeviceBufferMemoryRequirements,
                      deepcopy_VkDeviceBufferMemoryRequirementsKHR)

DEFINE_ALIAS_FUNCTION(deepcopy_VkDeviceImageMemoryRequirements,
                      deepcopy_VkDeviceImageMemoryRequirementsKHR)

#endif
#ifdef VK_KHR_ray_tracing_position_fetch
void deepcopy_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* from,
    VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* to);

#endif
#ifdef VK_ANDROID_native_buffer
void deepcopy_VkNativeBufferUsage2ANDROID(Allocator* alloc, VkStructureType rootType,
                                          const VkNativeBufferUsage2ANDROID* from,
                                          VkNativeBufferUsage2ANDROID* to);

void deepcopy_VkNativeBufferANDROID(Allocator* alloc, VkStructureType rootType,
                                    const VkNativeBufferANDROID* from, VkNativeBufferANDROID* to);

void deepcopy_VkSwapchainImageCreateInfoANDROID(Allocator* alloc, VkStructureType rootType,
                                                const VkSwapchainImageCreateInfoANDROID* from,
                                                VkSwapchainImageCreateInfoANDROID* to);

void deepcopy_VkPhysicalDevicePresentationPropertiesANDROID(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDevicePresentationPropertiesANDROID* from,
    VkPhysicalDevicePresentationPropertiesANDROID* to);

#endif
#ifdef VK_EXT_debug_report
void deepcopy_VkDebugReportCallbackCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
                                                 const VkDebugReportCallbackCreateInfoEXT* from,
                                                 VkDebugReportCallbackCreateInfoEXT* to);

#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 deepcopy_VkPipelineRasterizationStateRasterizationOrderAMD(
    Allocator* alloc, VkStructureType rootType,
    const VkPipelineRasterizationStateRasterizationOrderAMD* from,
    VkPipelineRasterizationStateRasterizationOrderAMD* to);

#endif
#ifdef VK_AMD_shader_trinary_minmax
#endif
#ifdef VK_AMD_shader_explicit_vertex_parameter
#endif
#ifdef VK_EXT_debug_marker
void deepcopy_VkDebugMarkerObjectNameInfoEXT(Allocator* alloc, VkStructureType rootType,
                                             const VkDebugMarkerObjectNameInfoEXT* from,
                                             VkDebugMarkerObjectNameInfoEXT* to);

void deepcopy_VkDebugMarkerObjectTagInfoEXT(Allocator* alloc, VkStructureType rootType,
                                            const VkDebugMarkerObjectTagInfoEXT* from,
                                            VkDebugMarkerObjectTagInfoEXT* to);

void deepcopy_VkDebugMarkerMarkerInfoEXT(Allocator* alloc, VkStructureType rootType,
                                         const VkDebugMarkerMarkerInfoEXT* from,
                                         VkDebugMarkerMarkerInfoEXT* to);

#endif
#ifdef VK_AMD_gcn_shader
#endif
#ifdef VK_NV_dedicated_allocation
void deepcopy_VkDedicatedAllocationImageCreateInfoNV(
    Allocator* alloc, VkStructureType rootType, const VkDedicatedAllocationImageCreateInfoNV* from,
    VkDedicatedAllocationImageCreateInfoNV* to);

void deepcopy_VkDedicatedAllocationBufferCreateInfoNV(
    Allocator* alloc, VkStructureType rootType, const VkDedicatedAllocationBufferCreateInfoNV* from,
    VkDedicatedAllocationBufferCreateInfoNV* to);

void deepcopy_VkDedicatedAllocationMemoryAllocateInfoNV(
    Allocator* alloc, VkStructureType rootType,
    const VkDedicatedAllocationMemoryAllocateInfoNV* from,
    VkDedicatedAllocationMemoryAllocateInfoNV* to);

#endif
#ifdef VK_EXT_transform_feedback
void deepcopy_VkPhysicalDeviceTransformFeedbackFeaturesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceTransformFeedbackFeaturesEXT* from,
    VkPhysicalDeviceTransformFeedbackFeaturesEXT* to);

void deepcopy_VkPhysicalDeviceTransformFeedbackPropertiesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceTransformFeedbackPropertiesEXT* from,
    VkPhysicalDeviceTransformFeedbackPropertiesEXT* to);

void deepcopy_VkPipelineRasterizationStateStreamCreateInfoEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPipelineRasterizationStateStreamCreateInfoEXT* from,
    VkPipelineRasterizationStateStreamCreateInfoEXT* to);

#endif
#ifdef VK_NVX_binary_import
void deepcopy_VkCuModuleCreateInfoNVX(Allocator* alloc, VkStructureType rootType,
                                      const VkCuModuleCreateInfoNVX* from,
                                      VkCuModuleCreateInfoNVX* to);

void deepcopy_VkCuFunctionCreateInfoNVX(Allocator* alloc, VkStructureType rootType,
                                        const VkCuFunctionCreateInfoNVX* from,
                                        VkCuFunctionCreateInfoNVX* to);

void deepcopy_VkCuLaunchInfoNVX(Allocator* alloc, VkStructureType rootType,
                                const VkCuLaunchInfoNVX* from, VkCuLaunchInfoNVX* to);

#endif
#ifdef VK_NVX_image_view_handle
void deepcopy_VkImageViewHandleInfoNVX(Allocator* alloc, VkStructureType rootType,
                                       const VkImageViewHandleInfoNVX* from,
                                       VkImageViewHandleInfoNVX* to);

void deepcopy_VkImageViewAddressPropertiesNVX(Allocator* alloc, VkStructureType rootType,
                                              const VkImageViewAddressPropertiesNVX* from,
                                              VkImageViewAddressPropertiesNVX* to);

#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 deepcopy_VkVideoEncodeH264CapabilitiesEXT(Allocator* alloc, VkStructureType rootType,
                                               const VkVideoEncodeH264CapabilitiesEXT* from,
                                               VkVideoEncodeH264CapabilitiesEXT* to);

void deepcopy_VkVideoEncodeH264SessionParametersAddInfoEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkVideoEncodeH264SessionParametersAddInfoEXT* from,
    VkVideoEncodeH264SessionParametersAddInfoEXT* to);

void deepcopy_VkVideoEncodeH264SessionParametersCreateInfoEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkVideoEncodeH264SessionParametersCreateInfoEXT* from,
    VkVideoEncodeH264SessionParametersCreateInfoEXT* to);

void deepcopy_VkVideoEncodeH264NaluSliceInfoEXT(Allocator* alloc, VkStructureType rootType,
                                                const VkVideoEncodeH264NaluSliceInfoEXT* from,
                                                VkVideoEncodeH264NaluSliceInfoEXT* to);

void deepcopy_VkVideoEncodeH264VclFrameInfoEXT(Allocator* alloc, VkStructureType rootType,
                                               const VkVideoEncodeH264VclFrameInfoEXT* from,
                                               VkVideoEncodeH264VclFrameInfoEXT* to);

void deepcopy_VkVideoEncodeH264DpbSlotInfoEXT(Allocator* alloc, VkStructureType rootType,
                                              const VkVideoEncodeH264DpbSlotInfoEXT* from,
                                              VkVideoEncodeH264DpbSlotInfoEXT* to);

void deepcopy_VkVideoEncodeH264ProfileInfoEXT(Allocator* alloc, VkStructureType rootType,
                                              const VkVideoEncodeH264ProfileInfoEXT* from,
                                              VkVideoEncodeH264ProfileInfoEXT* to);

void deepcopy_VkVideoEncodeH264RateControlInfoEXT(Allocator* alloc, VkStructureType rootType,
                                                  const VkVideoEncodeH264RateControlInfoEXT* from,
                                                  VkVideoEncodeH264RateControlInfoEXT* to);

void deepcopy_VkVideoEncodeH264QpEXT(Allocator* alloc, VkStructureType rootType,
                                     const VkVideoEncodeH264QpEXT* from,
                                     VkVideoEncodeH264QpEXT* to);

void deepcopy_VkVideoEncodeH264FrameSizeEXT(Allocator* alloc, VkStructureType rootType,
                                            const VkVideoEncodeH264FrameSizeEXT* from,
                                            VkVideoEncodeH264FrameSizeEXT* to);

void deepcopy_VkVideoEncodeH264RateControlLayerInfoEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkVideoEncodeH264RateControlLayerInfoEXT* from,
    VkVideoEncodeH264RateControlLayerInfoEXT* to);

#endif
#ifdef VK_EXT_video_encode_h265
void deepcopy_VkVideoEncodeH265CapabilitiesEXT(Allocator* alloc, VkStructureType rootType,
                                               const VkVideoEncodeH265CapabilitiesEXT* from,
                                               VkVideoEncodeH265CapabilitiesEXT* to);

void deepcopy_VkVideoEncodeH265SessionParametersAddInfoEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkVideoEncodeH265SessionParametersAddInfoEXT* from,
    VkVideoEncodeH265SessionParametersAddInfoEXT* to);

void deepcopy_VkVideoEncodeH265SessionParametersCreateInfoEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkVideoEncodeH265SessionParametersCreateInfoEXT* from,
    VkVideoEncodeH265SessionParametersCreateInfoEXT* to);

void deepcopy_VkVideoEncodeH265NaluSliceSegmentInfoEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkVideoEncodeH265NaluSliceSegmentInfoEXT* from,
    VkVideoEncodeH265NaluSliceSegmentInfoEXT* to);

void deepcopy_VkVideoEncodeH265VclFrameInfoEXT(Allocator* alloc, VkStructureType rootType,
                                               const VkVideoEncodeH265VclFrameInfoEXT* from,
                                               VkVideoEncodeH265VclFrameInfoEXT* to);

void deepcopy_VkVideoEncodeH265DpbSlotInfoEXT(Allocator* alloc, VkStructureType rootType,
                                              const VkVideoEncodeH265DpbSlotInfoEXT* from,
                                              VkVideoEncodeH265DpbSlotInfoEXT* to);

void deepcopy_VkVideoEncodeH265ProfileInfoEXT(Allocator* alloc, VkStructureType rootType,
                                              const VkVideoEncodeH265ProfileInfoEXT* from,
                                              VkVideoEncodeH265ProfileInfoEXT* to);

void deepcopy_VkVideoEncodeH265RateControlInfoEXT(Allocator* alloc, VkStructureType rootType,
                                                  const VkVideoEncodeH265RateControlInfoEXT* from,
                                                  VkVideoEncodeH265RateControlInfoEXT* to);

void deepcopy_VkVideoEncodeH265QpEXT(Allocator* alloc, VkStructureType rootType,
                                     const VkVideoEncodeH265QpEXT* from,
                                     VkVideoEncodeH265QpEXT* to);

void deepcopy_VkVideoEncodeH265FrameSizeEXT(Allocator* alloc, VkStructureType rootType,
                                            const VkVideoEncodeH265FrameSizeEXT* from,
                                            VkVideoEncodeH265FrameSizeEXT* to);

void deepcopy_VkVideoEncodeH265RateControlLayerInfoEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkVideoEncodeH265RateControlLayerInfoEXT* from,
    VkVideoEncodeH265RateControlLayerInfoEXT* to);

#endif
#ifdef VK_AMD_texture_gather_bias_lod
void deepcopy_VkTextureLODGatherFormatPropertiesAMD(
    Allocator* alloc, VkStructureType rootType, const VkTextureLODGatherFormatPropertiesAMD* from,
    VkTextureLODGatherFormatPropertiesAMD* to);

#endif
#ifdef VK_AMD_shader_info
void deepcopy_VkShaderResourceUsageAMD(Allocator* alloc, VkStructureType rootType,
                                       const VkShaderResourceUsageAMD* from,
                                       VkShaderResourceUsageAMD* to);

void deepcopy_VkShaderStatisticsInfoAMD(Allocator* alloc, VkStructureType rootType,
                                        const VkShaderStatisticsInfoAMD* from,
                                        VkShaderStatisticsInfoAMD* to);

#endif
#ifdef VK_AMD_shader_image_load_store_lod
#endif
#ifdef VK_GGP_stream_descriptor_surface
void deepcopy_VkStreamDescriptorSurfaceCreateInfoGGP(
    Allocator* alloc, VkStructureType rootType, const VkStreamDescriptorSurfaceCreateInfoGGP* from,
    VkStreamDescriptorSurfaceCreateInfoGGP* to);

#endif
#ifdef VK_NV_corner_sampled_image
void deepcopy_VkPhysicalDeviceCornerSampledImageFeaturesNV(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceCornerSampledImageFeaturesNV* from,
    VkPhysicalDeviceCornerSampledImageFeaturesNV* to);

#endif
#ifdef VK_IMG_format_pvrtc
#endif
#ifdef VK_NV_external_memory_capabilities
void deepcopy_VkExternalImageFormatPropertiesNV(Allocator* alloc, VkStructureType rootType,
                                                const VkExternalImageFormatPropertiesNV* from,
                                                VkExternalImageFormatPropertiesNV* to);

#endif
#ifdef VK_NV_external_memory
void deepcopy_VkExternalMemoryImageCreateInfoNV(Allocator* alloc, VkStructureType rootType,
                                                const VkExternalMemoryImageCreateInfoNV* from,
                                                VkExternalMemoryImageCreateInfoNV* to);

void deepcopy_VkExportMemoryAllocateInfoNV(Allocator* alloc, VkStructureType rootType,
                                           const VkExportMemoryAllocateInfoNV* from,
                                           VkExportMemoryAllocateInfoNV* to);

#endif
#ifdef VK_NV_external_memory_win32
void deepcopy_VkImportMemoryWin32HandleInfoNV(Allocator* alloc, VkStructureType rootType,
                                              const VkImportMemoryWin32HandleInfoNV* from,
                                              VkImportMemoryWin32HandleInfoNV* to);

void deepcopy_VkExportMemoryWin32HandleInfoNV(Allocator* alloc, VkStructureType rootType,
                                              const VkExportMemoryWin32HandleInfoNV* from,
                                              VkExportMemoryWin32HandleInfoNV* to);

#endif
#ifdef VK_NV_win32_keyed_mutex
void deepcopy_VkWin32KeyedMutexAcquireReleaseInfoNV(
    Allocator* alloc, VkStructureType rootType, const VkWin32KeyedMutexAcquireReleaseInfoNV* from,
    VkWin32KeyedMutexAcquireReleaseInfoNV* to);

#endif
#ifdef VK_EXT_validation_flags
void deepcopy_VkValidationFlagsEXT(Allocator* alloc, VkStructureType rootType,
                                   const VkValidationFlagsEXT* from, VkValidationFlagsEXT* to);

#endif
#ifdef VK_NN_vi_surface
void deepcopy_VkViSurfaceCreateInfoNN(Allocator* alloc, VkStructureType rootType,
                                      const VkViSurfaceCreateInfoNN* from,
                                      VkViSurfaceCreateInfoNN* to);

#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(deepcopy_VkPhysicalDeviceTextureCompressionASTCHDRFeatures,
                      deepcopy_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT)

#endif
#ifdef VK_EXT_astc_decode_mode
void deepcopy_VkImageViewASTCDecodeModeEXT(Allocator* alloc, VkStructureType rootType,
                                           const VkImageViewASTCDecodeModeEXT* from,
                                           VkImageViewASTCDecodeModeEXT* to);

void deepcopy_VkPhysicalDeviceASTCDecodeFeaturesEXT(
    Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceASTCDecodeFeaturesEXT* from,
    VkPhysicalDeviceASTCDecodeFeaturesEXT* to);

#endif
#ifdef VK_EXT_pipeline_robustness
void deepcopy_VkPhysicalDevicePipelineRobustnessFeaturesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDevicePipelineRobustnessFeaturesEXT* from,
    VkPhysicalDevicePipelineRobustnessFeaturesEXT* to);

void deepcopy_VkPhysicalDevicePipelineRobustnessPropertiesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDevicePipelineRobustnessPropertiesEXT* from,
    VkPhysicalDevicePipelineRobustnessPropertiesEXT* to);

void deepcopy_VkPipelineRobustnessCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
                                                const VkPipelineRobustnessCreateInfoEXT* from,
                                                VkPipelineRobustnessCreateInfoEXT* to);

#endif
#ifdef VK_EXT_conditional_rendering
void deepcopy_VkConditionalRenderingBeginInfoEXT(Allocator* alloc, VkStructureType rootType,
                                                 const VkConditionalRenderingBeginInfoEXT* from,
                                                 VkConditionalRenderingBeginInfoEXT* to);

void deepcopy_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceConditionalRenderingFeaturesEXT* from,
    VkPhysicalDeviceConditionalRenderingFeaturesEXT* to);

void deepcopy_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkCommandBufferInheritanceConditionalRenderingInfoEXT* from,
    VkCommandBufferInheritanceConditionalRenderingInfoEXT* to);

#endif
#ifdef VK_NV_clip_space_w_scaling
void deepcopy_VkViewportWScalingNV(Allocator* alloc, VkStructureType rootType,
                                   const VkViewportWScalingNV* from, VkViewportWScalingNV* to);

void deepcopy_VkPipelineViewportWScalingStateCreateInfoNV(
    Allocator* alloc, VkStructureType rootType,
    const VkPipelineViewportWScalingStateCreateInfoNV* from,
    VkPipelineViewportWScalingStateCreateInfoNV* to);

#endif
#ifdef VK_EXT_direct_mode_display
#endif
#ifdef VK_EXT_acquire_xlib_display
#endif
#ifdef VK_EXT_display_surface_counter
void deepcopy_VkSurfaceCapabilities2EXT(Allocator* alloc, VkStructureType rootType,
                                        const VkSurfaceCapabilities2EXT* from,
                                        VkSurfaceCapabilities2EXT* to);

#endif
#ifdef VK_EXT_display_control
void deepcopy_VkDisplayPowerInfoEXT(Allocator* alloc, VkStructureType rootType,
                                    const VkDisplayPowerInfoEXT* from, VkDisplayPowerInfoEXT* to);

void deepcopy_VkDeviceEventInfoEXT(Allocator* alloc, VkStructureType rootType,
                                   const VkDeviceEventInfoEXT* from, VkDeviceEventInfoEXT* to);

void deepcopy_VkDisplayEventInfoEXT(Allocator* alloc, VkStructureType rootType,
                                    const VkDisplayEventInfoEXT* from, VkDisplayEventInfoEXT* to);

void deepcopy_VkSwapchainCounterCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
                                              const VkSwapchainCounterCreateInfoEXT* from,
                                              VkSwapchainCounterCreateInfoEXT* to);

#endif
#ifdef VK_GOOGLE_display_timing
void deepcopy_VkRefreshCycleDurationGOOGLE(Allocator* alloc, VkStructureType rootType,
                                           const VkRefreshCycleDurationGOOGLE* from,
                                           VkRefreshCycleDurationGOOGLE* to);

void deepcopy_VkPastPresentationTimingGOOGLE(Allocator* alloc, VkStructureType rootType,
                                             const VkPastPresentationTimingGOOGLE* from,
                                             VkPastPresentationTimingGOOGLE* to);

void deepcopy_VkPresentTimeGOOGLE(Allocator* alloc, VkStructureType rootType,
                                  const VkPresentTimeGOOGLE* from, VkPresentTimeGOOGLE* to);

void deepcopy_VkPresentTimesInfoGOOGLE(Allocator* alloc, VkStructureType rootType,
                                       const VkPresentTimesInfoGOOGLE* from,
                                       VkPresentTimesInfoGOOGLE* to);

#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 deepcopy_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* from,
    VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* to);

#endif
#ifdef VK_NV_viewport_swizzle
void deepcopy_VkViewportSwizzleNV(Allocator* alloc, VkStructureType rootType,
                                  const VkViewportSwizzleNV* from, VkViewportSwizzleNV* to);

void deepcopy_VkPipelineViewportSwizzleStateCreateInfoNV(
    Allocator* alloc, VkStructureType rootType,
    const VkPipelineViewportSwizzleStateCreateInfoNV* from,
    VkPipelineViewportSwizzleStateCreateInfoNV* to);

#endif
#ifdef VK_EXT_discard_rectangles
void deepcopy_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceDiscardRectanglePropertiesEXT* from,
    VkPhysicalDeviceDiscardRectanglePropertiesEXT* to);

void deepcopy_VkPipelineDiscardRectangleStateCreateInfoEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPipelineDiscardRectangleStateCreateInfoEXT* from,
    VkPipelineDiscardRectangleStateCreateInfoEXT* to);

#endif
#ifdef VK_EXT_conservative_rasterization
void deepcopy_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceConservativeRasterizationPropertiesEXT* from,
    VkPhysicalDeviceConservativeRasterizationPropertiesEXT* to);

void deepcopy_VkPipelineRasterizationConservativeStateCreateInfoEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPipelineRasterizationConservativeStateCreateInfoEXT* from,
    VkPipelineRasterizationConservativeStateCreateInfoEXT* to);

#endif
#ifdef VK_EXT_depth_clip_enable
void deepcopy_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceDepthClipEnableFeaturesEXT* from,
    VkPhysicalDeviceDepthClipEnableFeaturesEXT* to);

void deepcopy_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPipelineRasterizationDepthClipStateCreateInfoEXT* from,
    VkPipelineRasterizationDepthClipStateCreateInfoEXT* to);

#endif
#ifdef VK_EXT_swapchain_colorspace
#endif
#ifdef VK_EXT_hdr_metadata
void deepcopy_VkXYColorEXT(Allocator* alloc, VkStructureType rootType, const VkXYColorEXT* from,
                           VkXYColorEXT* to);

void deepcopy_VkHdrMetadataEXT(Allocator* alloc, VkStructureType rootType,
                               const VkHdrMetadataEXT* from, VkHdrMetadataEXT* to);

#endif
#ifdef VK_MVK_ios_surface
void deepcopy_VkIOSSurfaceCreateInfoMVK(Allocator* alloc, VkStructureType rootType,
                                        const VkIOSSurfaceCreateInfoMVK* from,
                                        VkIOSSurfaceCreateInfoMVK* to);

#endif
#ifdef VK_MVK_macos_surface
void deepcopy_VkMacOSSurfaceCreateInfoMVK(Allocator* alloc, VkStructureType rootType,
                                          const VkMacOSSurfaceCreateInfoMVK* from,
                                          VkMacOSSurfaceCreateInfoMVK* to);

#endif
#ifdef VK_EXT_external_memory_dma_buf
#endif
#ifdef VK_EXT_queue_family_foreign
#endif
#ifdef VK_EXT_debug_utils
void deepcopy_VkDebugUtilsLabelEXT(Allocator* alloc, VkStructureType rootType,
                                   const VkDebugUtilsLabelEXT* from, VkDebugUtilsLabelEXT* to);

void deepcopy_VkDebugUtilsObjectNameInfoEXT(Allocator* alloc, VkStructureType rootType,
                                            const VkDebugUtilsObjectNameInfoEXT* from,
                                            VkDebugUtilsObjectNameInfoEXT* to);

void deepcopy_VkDebugUtilsMessengerCallbackDataEXT(Allocator* alloc, VkStructureType rootType,
                                                   const VkDebugUtilsMessengerCallbackDataEXT* from,
                                                   VkDebugUtilsMessengerCallbackDataEXT* to);

void deepcopy_VkDebugUtilsMessengerCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
                                                 const VkDebugUtilsMessengerCreateInfoEXT* from,
                                                 VkDebugUtilsMessengerCreateInfoEXT* to);

void deepcopy_VkDebugUtilsObjectTagInfoEXT(Allocator* alloc, VkStructureType rootType,
                                           const VkDebugUtilsObjectTagInfoEXT* from,
                                           VkDebugUtilsObjectTagInfoEXT* to);

#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
void deepcopy_VkAndroidHardwareBufferUsageANDROID(Allocator* alloc, VkStructureType rootType,
                                                  const VkAndroidHardwareBufferUsageANDROID* from,
                                                  VkAndroidHardwareBufferUsageANDROID* to);

void deepcopy_VkAndroidHardwareBufferPropertiesANDROID(
    Allocator* alloc, VkStructureType rootType,
    const VkAndroidHardwareBufferPropertiesANDROID* from,
    VkAndroidHardwareBufferPropertiesANDROID* to);

void deepcopy_VkAndroidHardwareBufferFormatPropertiesANDROID(
    Allocator* alloc, VkStructureType rootType,
    const VkAndroidHardwareBufferFormatPropertiesANDROID* from,
    VkAndroidHardwareBufferFormatPropertiesANDROID* to);

void deepcopy_VkImportAndroidHardwareBufferInfoANDROID(
    Allocator* alloc, VkStructureType rootType,
    const VkImportAndroidHardwareBufferInfoANDROID* from,
    VkImportAndroidHardwareBufferInfoANDROID* to);

void deepcopy_VkMemoryGetAndroidHardwareBufferInfoANDROID(
    Allocator* alloc, VkStructureType rootType,
    const VkMemoryGetAndroidHardwareBufferInfoANDROID* from,
    VkMemoryGetAndroidHardwareBufferInfoANDROID* to);

void deepcopy_VkExternalFormatANDROID(Allocator* alloc, VkStructureType rootType,
                                      const VkExternalFormatANDROID* from,
                                      VkExternalFormatANDROID* to);

void deepcopy_VkAndroidHardwareBufferFormatProperties2ANDROID(
    Allocator* alloc, VkStructureType rootType,
    const VkAndroidHardwareBufferFormatProperties2ANDROID* from,
    VkAndroidHardwareBufferFormatProperties2ANDROID* to);

#endif
#ifdef VK_EXT_sampler_filter_minmax
DEFINE_ALIAS_FUNCTION(deepcopy_VkSamplerReductionModeCreateInfo,
                      deepcopy_VkSamplerReductionModeCreateInfoEXT)

DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceSamplerFilterMinmaxProperties,
                      deepcopy_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(deepcopy_VkPhysicalDeviceInlineUniformBlockFeatures,
                      deepcopy_VkPhysicalDeviceInlineUniformBlockFeaturesEXT)

DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceInlineUniformBlockProperties,
                      deepcopy_VkPhysicalDeviceInlineUniformBlockPropertiesEXT)

DEFINE_ALIAS_FUNCTION(deepcopy_VkWriteDescriptorSetInlineUniformBlock,
                      deepcopy_VkWriteDescriptorSetInlineUniformBlockEXT)

DEFINE_ALIAS_FUNCTION(deepcopy_VkDescriptorPoolInlineUniformBlockCreateInfo,
                      deepcopy_VkDescriptorPoolInlineUniformBlockCreateInfoEXT)

#endif
#ifdef VK_EXT_shader_stencil_export
#endif
#ifdef VK_EXT_sample_locations
void deepcopy_VkSampleLocationEXT(Allocator* alloc, VkStructureType rootType,
                                  const VkSampleLocationEXT* from, VkSampleLocationEXT* to);

void deepcopy_VkSampleLocationsInfoEXT(Allocator* alloc, VkStructureType rootType,
                                       const VkSampleLocationsInfoEXT* from,
                                       VkSampleLocationsInfoEXT* to);

void deepcopy_VkAttachmentSampleLocationsEXT(Allocator* alloc, VkStructureType rootType,
                                             const VkAttachmentSampleLocationsEXT* from,
                                             VkAttachmentSampleLocationsEXT* to);

void deepcopy_VkSubpassSampleLocationsEXT(Allocator* alloc, VkStructureType rootType,
                                          const VkSubpassSampleLocationsEXT* from,
                                          VkSubpassSampleLocationsEXT* to);

void deepcopy_VkRenderPassSampleLocationsBeginInfoEXT(
    Allocator* alloc, VkStructureType rootType, const VkRenderPassSampleLocationsBeginInfoEXT* from,
    VkRenderPassSampleLocationsBeginInfoEXT* to);

void deepcopy_VkPipelineSampleLocationsStateCreateInfoEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPipelineSampleLocationsStateCreateInfoEXT* from,
    VkPipelineSampleLocationsStateCreateInfoEXT* to);

void deepcopy_VkPhysicalDeviceSampleLocationsPropertiesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceSampleLocationsPropertiesEXT* from,
    VkPhysicalDeviceSampleLocationsPropertiesEXT* to);

void deepcopy_VkMultisamplePropertiesEXT(Allocator* alloc, VkStructureType rootType,
                                         const VkMultisamplePropertiesEXT* from,
                                         VkMultisamplePropertiesEXT* to);

#endif
#ifdef VK_EXT_blend_operation_advanced
void deepcopy_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* from,
    VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* to);

void deepcopy_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* from,
    VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* to);

void deepcopy_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPipelineColorBlendAdvancedStateCreateInfoEXT* from,
    VkPipelineColorBlendAdvancedStateCreateInfoEXT* to);

#endif
#ifdef VK_NV_fragment_coverage_to_color
void deepcopy_VkPipelineCoverageToColorStateCreateInfoNV(
    Allocator* alloc, VkStructureType rootType,
    const VkPipelineCoverageToColorStateCreateInfoNV* from,
    VkPipelineCoverageToColorStateCreateInfoNV* to);

#endif
#ifdef VK_NV_framebuffer_mixed_samples
void deepcopy_VkPipelineCoverageModulationStateCreateInfoNV(
    Allocator* alloc, VkStructureType rootType,
    const VkPipelineCoverageModulationStateCreateInfoNV* from,
    VkPipelineCoverageModulationStateCreateInfoNV* to);

#endif
#ifdef VK_NV_fill_rectangle
#endif
#ifdef VK_NV_shader_sm_builtins
void deepcopy_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* from,
    VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* to);

void deepcopy_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* from,
    VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* to);

#endif
#ifdef VK_EXT_post_depth_coverage
#endif
#ifdef VK_EXT_image_drm_format_modifier
void deepcopy_VkDrmFormatModifierPropertiesEXT(Allocator* alloc, VkStructureType rootType,
                                               const VkDrmFormatModifierPropertiesEXT* from,
                                               VkDrmFormatModifierPropertiesEXT* to);

void deepcopy_VkDrmFormatModifierPropertiesListEXT(Allocator* alloc, VkStructureType rootType,
                                                   const VkDrmFormatModifierPropertiesListEXT* from,
                                                   VkDrmFormatModifierPropertiesListEXT* to);

void deepcopy_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceImageDrmFormatModifierInfoEXT* from,
    VkPhysicalDeviceImageDrmFormatModifierInfoEXT* to);

void deepcopy_VkImageDrmFormatModifierListCreateInfoEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkImageDrmFormatModifierListCreateInfoEXT* from,
    VkImageDrmFormatModifierListCreateInfoEXT* to);

void deepcopy_VkImageDrmFormatModifierExplicitCreateInfoEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkImageDrmFormatModifierExplicitCreateInfoEXT* from,
    VkImageDrmFormatModifierExplicitCreateInfoEXT* to);

void deepcopy_VkImageDrmFormatModifierPropertiesEXT(
    Allocator* alloc, VkStructureType rootType, const VkImageDrmFormatModifierPropertiesEXT* from,
    VkImageDrmFormatModifierPropertiesEXT* to);

void deepcopy_VkDrmFormatModifierProperties2EXT(Allocator* alloc, VkStructureType rootType,
                                                const VkDrmFormatModifierProperties2EXT* from,
                                                VkDrmFormatModifierProperties2EXT* to);

void deepcopy_VkDrmFormatModifierPropertiesList2EXT(
    Allocator* alloc, VkStructureType rootType, const VkDrmFormatModifierPropertiesList2EXT* from,
    VkDrmFormatModifierPropertiesList2EXT* to);

#endif
#ifdef VK_EXT_validation_cache
void deepcopy_VkValidationCacheCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
                                             const VkValidationCacheCreateInfoEXT* from,
                                             VkValidationCacheCreateInfoEXT* to);

void deepcopy_VkShaderModuleValidationCacheCreateInfoEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkShaderModuleValidationCacheCreateInfoEXT* from,
    VkShaderModuleValidationCacheCreateInfoEXT* to);

#endif
#ifdef VK_EXT_descriptor_indexing
DEFINE_ALIAS_FUNCTION(deepcopy_VkDescriptorSetLayoutBindingFlagsCreateInfo,
                      deepcopy_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT)

DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceDescriptorIndexingFeatures,
                      deepcopy_VkPhysicalDeviceDescriptorIndexingFeaturesEXT)

DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceDescriptorIndexingProperties,
                      deepcopy_VkPhysicalDeviceDescriptorIndexingPropertiesEXT)

DEFINE_ALIAS_FUNCTION(deepcopy_VkDescriptorSetVariableDescriptorCountAllocateInfo,
                      deepcopy_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT)

DEFINE_ALIAS_FUNCTION(deepcopy_VkDescriptorSetVariableDescriptorCountLayoutSupport,
                      deepcopy_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT)

#endif
#ifdef VK_EXT_shader_viewport_index_layer
#endif
#ifdef VK_NV_shading_rate_image
void deepcopy_VkShadingRatePaletteNV(Allocator* alloc, VkStructureType rootType,
                                     const VkShadingRatePaletteNV* from,
                                     VkShadingRatePaletteNV* to);

void deepcopy_VkPipelineViewportShadingRateImageStateCreateInfoNV(
    Allocator* alloc, VkStructureType rootType,
    const VkPipelineViewportShadingRateImageStateCreateInfoNV* from,
    VkPipelineViewportShadingRateImageStateCreateInfoNV* to);

void deepcopy_VkPhysicalDeviceShadingRateImageFeaturesNV(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceShadingRateImageFeaturesNV* from,
    VkPhysicalDeviceShadingRateImageFeaturesNV* to);

void deepcopy_VkPhysicalDeviceShadingRateImagePropertiesNV(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceShadingRateImagePropertiesNV* from,
    VkPhysicalDeviceShadingRateImagePropertiesNV* to);

void deepcopy_VkCoarseSampleLocationNV(Allocator* alloc, VkStructureType rootType,
                                       const VkCoarseSampleLocationNV* from,
                                       VkCoarseSampleLocationNV* to);

void deepcopy_VkCoarseSampleOrderCustomNV(Allocator* alloc, VkStructureType rootType,
                                          const VkCoarseSampleOrderCustomNV* from,
                                          VkCoarseSampleOrderCustomNV* to);

void deepcopy_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(
    Allocator* alloc, VkStructureType rootType,
    const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* from,
    VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* to);

#endif
#ifdef VK_NV_ray_tracing
void deepcopy_VkRayTracingShaderGroupCreateInfoNV(Allocator* alloc, VkStructureType rootType,
                                                  const VkRayTracingShaderGroupCreateInfoNV* from,
                                                  VkRayTracingShaderGroupCreateInfoNV* to);

void deepcopy_VkRayTracingPipelineCreateInfoNV(Allocator* alloc, VkStructureType rootType,
                                               const VkRayTracingPipelineCreateInfoNV* from,
                                               VkRayTracingPipelineCreateInfoNV* to);

void deepcopy_VkGeometryTrianglesNV(Allocator* alloc, VkStructureType rootType,
                                    const VkGeometryTrianglesNV* from, VkGeometryTrianglesNV* to);

void deepcopy_VkGeometryAABBNV(Allocator* alloc, VkStructureType rootType,
                               const VkGeometryAABBNV* from, VkGeometryAABBNV* to);

void deepcopy_VkGeometryDataNV(Allocator* alloc, VkStructureType rootType,
                               const VkGeometryDataNV* from, VkGeometryDataNV* to);

void deepcopy_VkGeometryNV(Allocator* alloc, VkStructureType rootType, const VkGeometryNV* from,
                           VkGeometryNV* to);

void deepcopy_VkAccelerationStructureInfoNV(Allocator* alloc, VkStructureType rootType,
                                            const VkAccelerationStructureInfoNV* from,
                                            VkAccelerationStructureInfoNV* to);

void deepcopy_VkAccelerationStructureCreateInfoNV(Allocator* alloc, VkStructureType rootType,
                                                  const VkAccelerationStructureCreateInfoNV* from,
                                                  VkAccelerationStructureCreateInfoNV* to);

void deepcopy_VkBindAccelerationStructureMemoryInfoNV(
    Allocator* alloc, VkStructureType rootType, const VkBindAccelerationStructureMemoryInfoNV* from,
    VkBindAccelerationStructureMemoryInfoNV* to);

void deepcopy_VkWriteDescriptorSetAccelerationStructureNV(
    Allocator* alloc, VkStructureType rootType,
    const VkWriteDescriptorSetAccelerationStructureNV* from,
    VkWriteDescriptorSetAccelerationStructureNV* to);

void deepcopy_VkAccelerationStructureMemoryRequirementsInfoNV(
    Allocator* alloc, VkStructureType rootType,
    const VkAccelerationStructureMemoryRequirementsInfoNV* from,
    VkAccelerationStructureMemoryRequirementsInfoNV* to);

void deepcopy_VkPhysicalDeviceRayTracingPropertiesNV(
    Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceRayTracingPropertiesNV* from,
    VkPhysicalDeviceRayTracingPropertiesNV* to);

void deepcopy_VkTransformMatrixKHR(Allocator* alloc, VkStructureType rootType,
                                   const VkTransformMatrixKHR* from, VkTransformMatrixKHR* to);

DEFINE_ALIAS_FUNCTION(deepcopy_VkTransformMatrixKHR, deepcopy_VkTransformMatrixNV)

void deepcopy_VkAabbPositionsKHR(Allocator* alloc, VkStructureType rootType,
                                 const VkAabbPositionsKHR* from, VkAabbPositionsKHR* to);

DEFINE_ALIAS_FUNCTION(deepcopy_VkAabbPositionsKHR, deepcopy_VkAabbPositionsNV)

void deepcopy_VkAccelerationStructureInstanceKHR(Allocator* alloc, VkStructureType rootType,
                                                 const VkAccelerationStructureInstanceKHR* from,
                                                 VkAccelerationStructureInstanceKHR* to);

DEFINE_ALIAS_FUNCTION(deepcopy_VkAccelerationStructureInstanceKHR,
                      deepcopy_VkAccelerationStructureInstanceNV)

#endif
#ifdef VK_NV_representative_fragment_test
void deepcopy_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* from,
    VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* to);

void deepcopy_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(
    Allocator* alloc, VkStructureType rootType,
    const VkPipelineRepresentativeFragmentTestStateCreateInfoNV* from,
    VkPipelineRepresentativeFragmentTestStateCreateInfoNV* to);

#endif
#ifdef VK_EXT_filter_cubic
void deepcopy_VkPhysicalDeviceImageViewImageFormatInfoEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceImageViewImageFormatInfoEXT* from,
    VkPhysicalDeviceImageViewImageFormatInfoEXT* to);

void deepcopy_VkFilterCubicImageViewImageFormatPropertiesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkFilterCubicImageViewImageFormatPropertiesEXT* from,
    VkFilterCubicImageViewImageFormatPropertiesEXT* to);

#endif
#ifdef VK_QCOM_render_pass_shader_resolve
#endif
#ifdef VK_EXT_global_priority
DEFINE_ALIAS_FUNCTION(deepcopy_VkDeviceQueueGlobalPriorityCreateInfoKHR,
                      deepcopy_VkDeviceQueueGlobalPriorityCreateInfoEXT)

#endif
#ifdef VK_EXT_external_memory_host
void deepcopy_VkImportMemoryHostPointerInfoEXT(Allocator* alloc, VkStructureType rootType,
                                               const VkImportMemoryHostPointerInfoEXT* from,
                                               VkImportMemoryHostPointerInfoEXT* to);

void deepcopy_VkMemoryHostPointerPropertiesEXT(Allocator* alloc, VkStructureType rootType,
                                               const VkMemoryHostPointerPropertiesEXT* from,
                                               VkMemoryHostPointerPropertiesEXT* to);

void deepcopy_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceExternalMemoryHostPropertiesEXT* from,
    VkPhysicalDeviceExternalMemoryHostPropertiesEXT* to);

#endif
#ifdef VK_AMD_buffer_marker
#endif
#ifdef VK_AMD_pipeline_compiler_control
void deepcopy_VkPipelineCompilerControlCreateInfoAMD(
    Allocator* alloc, VkStructureType rootType, const VkPipelineCompilerControlCreateInfoAMD* from,
    VkPipelineCompilerControlCreateInfoAMD* to);

#endif
#ifdef VK_EXT_calibrated_timestamps
void deepcopy_VkCalibratedTimestampInfoEXT(Allocator* alloc, VkStructureType rootType,
                                           const VkCalibratedTimestampInfoEXT* from,
                                           VkCalibratedTimestampInfoEXT* to);

#endif
#ifdef VK_AMD_shader_core_properties
void deepcopy_VkPhysicalDeviceShaderCorePropertiesAMD(
    Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceShaderCorePropertiesAMD* from,
    VkPhysicalDeviceShaderCorePropertiesAMD* to);

#endif
#ifdef VK_AMD_memory_overallocation_behavior
void deepcopy_VkDeviceMemoryOverallocationCreateInfoAMD(
    Allocator* alloc, VkStructureType rootType,
    const VkDeviceMemoryOverallocationCreateInfoAMD* from,
    VkDeviceMemoryOverallocationCreateInfoAMD* to);

#endif
#ifdef VK_EXT_vertex_attribute_divisor
void deepcopy_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* from,
    VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* to);

void deepcopy_VkVertexInputBindingDivisorDescriptionEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkVertexInputBindingDivisorDescriptionEXT* from,
    VkVertexInputBindingDivisorDescriptionEXT* to);

void deepcopy_VkPipelineVertexInputDivisorStateCreateInfoEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPipelineVertexInputDivisorStateCreateInfoEXT* from,
    VkPipelineVertexInputDivisorStateCreateInfoEXT* to);

void deepcopy_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* from,
    VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* to);

#endif
#ifdef VK_GGP_frame_token
void deepcopy_VkPresentFrameTokenGGP(Allocator* alloc, VkStructureType rootType,
                                     const VkPresentFrameTokenGGP* from,
                                     VkPresentFrameTokenGGP* to);

#endif
#ifdef VK_EXT_pipeline_creation_feedback
DEFINE_ALIAS_FUNCTION(deepcopy_VkPipelineCreationFeedbackCreateInfo,
                      deepcopy_VkPipelineCreationFeedbackCreateInfoEXT)

DEFINE_ALIAS_FUNCTION(deepcopy_VkPipelineCreationFeedback, deepcopy_VkPipelineCreationFeedbackEXT)

#endif
#ifdef VK_NV_shader_subgroup_partitioned
#endif
#ifdef VK_NV_compute_shader_derivatives
void deepcopy_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* from,
    VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* to);

#endif
#ifdef VK_NV_mesh_shader
void deepcopy_VkPhysicalDeviceMeshShaderFeaturesNV(Allocator* alloc, VkStructureType rootType,
                                                   const VkPhysicalDeviceMeshShaderFeaturesNV* from,
                                                   VkPhysicalDeviceMeshShaderFeaturesNV* to);

void deepcopy_VkPhysicalDeviceMeshShaderPropertiesNV(
    Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceMeshShaderPropertiesNV* from,
    VkPhysicalDeviceMeshShaderPropertiesNV* to);

void deepcopy_VkDrawMeshTasksIndirectCommandNV(Allocator* alloc, VkStructureType rootType,
                                               const VkDrawMeshTasksIndirectCommandNV* from,
                                               VkDrawMeshTasksIndirectCommandNV* to);

#endif
#ifdef VK_NV_fragment_shader_barycentric
DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR,
                      deepcopy_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV)

#endif
#ifdef VK_NV_shader_image_footprint
void deepcopy_VkPhysicalDeviceShaderImageFootprintFeaturesNV(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceShaderImageFootprintFeaturesNV* from,
    VkPhysicalDeviceShaderImageFootprintFeaturesNV* to);

#endif
#ifdef VK_NV_scissor_exclusive
void deepcopy_VkPipelineViewportExclusiveScissorStateCreateInfoNV(
    Allocator* alloc, VkStructureType rootType,
    const VkPipelineViewportExclusiveScissorStateCreateInfoNV* from,
    VkPipelineViewportExclusiveScissorStateCreateInfoNV* to);

void deepcopy_VkPhysicalDeviceExclusiveScissorFeaturesNV(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceExclusiveScissorFeaturesNV* from,
    VkPhysicalDeviceExclusiveScissorFeaturesNV* to);

#endif
#ifdef VK_NV_device_diagnostic_checkpoints
void deepcopy_VkQueueFamilyCheckpointPropertiesNV(Allocator* alloc, VkStructureType rootType,
                                                  const VkQueueFamilyCheckpointPropertiesNV* from,
                                                  VkQueueFamilyCheckpointPropertiesNV* to);

void deepcopy_VkCheckpointDataNV(Allocator* alloc, VkStructureType rootType,
                                 const VkCheckpointDataNV* from, VkCheckpointDataNV* to);

#endif
#ifdef VK_INTEL_shader_integer_functions2
void deepcopy_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* from,
    VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* to);

#endif
#ifdef VK_INTEL_performance_query
void deepcopy_VkPerformanceValueDataINTEL(Allocator* alloc, VkStructureType rootType,
                                          const VkPerformanceValueDataINTEL* from,
                                          VkPerformanceValueDataINTEL* to);

void deepcopy_VkPerformanceValueINTEL(Allocator* alloc, VkStructureType rootType,
                                      const VkPerformanceValueINTEL* from,
                                      VkPerformanceValueINTEL* to);

void deepcopy_VkInitializePerformanceApiInfoINTEL(Allocator* alloc, VkStructureType rootType,
                                                  const VkInitializePerformanceApiInfoINTEL* from,
                                                  VkInitializePerformanceApiInfoINTEL* to);

void deepcopy_VkQueryPoolPerformanceQueryCreateInfoINTEL(
    Allocator* alloc, VkStructureType rootType,
    const VkQueryPoolPerformanceQueryCreateInfoINTEL* from,
    VkQueryPoolPerformanceQueryCreateInfoINTEL* to);

DEFINE_ALIAS_FUNCTION(deepcopy_VkQueryPoolPerformanceQueryCreateInfoINTEL,
                      deepcopy_VkQueryPoolCreateInfoINTEL)

void deepcopy_VkPerformanceMarkerInfoINTEL(Allocator* alloc, VkStructureType rootType,
                                           const VkPerformanceMarkerInfoINTEL* from,
                                           VkPerformanceMarkerInfoINTEL* to);

void deepcopy_VkPerformanceStreamMarkerInfoINTEL(Allocator* alloc, VkStructureType rootType,
                                                 const VkPerformanceStreamMarkerInfoINTEL* from,
                                                 VkPerformanceStreamMarkerInfoINTEL* to);

void deepcopy_VkPerformanceOverrideInfoINTEL(Allocator* alloc, VkStructureType rootType,
                                             const VkPerformanceOverrideInfoINTEL* from,
                                             VkPerformanceOverrideInfoINTEL* to);

void deepcopy_VkPerformanceConfigurationAcquireInfoINTEL(
    Allocator* alloc, VkStructureType rootType,
    const VkPerformanceConfigurationAcquireInfoINTEL* from,
    VkPerformanceConfigurationAcquireInfoINTEL* to);

#endif
#ifdef VK_EXT_pci_bus_info
void deepcopy_VkPhysicalDevicePCIBusInfoPropertiesEXT(
    Allocator* alloc, VkStructureType rootType, const VkPhysicalDevicePCIBusInfoPropertiesEXT* from,
    VkPhysicalDevicePCIBusInfoPropertiesEXT* to);

#endif
#ifdef VK_AMD_display_native_hdr
void deepcopy_VkDisplayNativeHdrSurfaceCapabilitiesAMD(
    Allocator* alloc, VkStructureType rootType,
    const VkDisplayNativeHdrSurfaceCapabilitiesAMD* from,
    VkDisplayNativeHdrSurfaceCapabilitiesAMD* to);

void deepcopy_VkSwapchainDisplayNativeHdrCreateInfoAMD(
    Allocator* alloc, VkStructureType rootType,
    const VkSwapchainDisplayNativeHdrCreateInfoAMD* from,
    VkSwapchainDisplayNativeHdrCreateInfoAMD* to);

#endif
#ifdef VK_FUCHSIA_imagepipe_surface
void deepcopy_VkImagePipeSurfaceCreateInfoFUCHSIA(Allocator* alloc, VkStructureType rootType,
                                                  const VkImagePipeSurfaceCreateInfoFUCHSIA* from,
                                                  VkImagePipeSurfaceCreateInfoFUCHSIA* to);

#endif
#ifdef VK_EXT_metal_surface
void deepcopy_VkMetalSurfaceCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
                                          const VkMetalSurfaceCreateInfoEXT* from,
                                          VkMetalSurfaceCreateInfoEXT* to);

#endif
#ifdef VK_EXT_fragment_density_map
void deepcopy_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceFragmentDensityMapFeaturesEXT* from,
    VkPhysicalDeviceFragmentDensityMapFeaturesEXT* to);

void deepcopy_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceFragmentDensityMapPropertiesEXT* from,
    VkPhysicalDeviceFragmentDensityMapPropertiesEXT* to);

void deepcopy_VkRenderPassFragmentDensityMapCreateInfoEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkRenderPassFragmentDensityMapCreateInfoEXT* from,
    VkRenderPassFragmentDensityMapCreateInfoEXT* to);

#endif
#ifdef VK_EXT_scalar_block_layout
DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceScalarBlockLayoutFeatures,
                      deepcopy_VkPhysicalDeviceScalarBlockLayoutFeaturesEXT)

#endif
#ifdef VK_GOOGLE_hlsl_functionality1
#endif
#ifdef VK_GOOGLE_decorate_string
#endif
#ifdef VK_EXT_subgroup_size_control
DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceSubgroupSizeControlFeatures,
                      deepcopy_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT)

DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceSubgroupSizeControlProperties,
                      deepcopy_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT)

DEFINE_ALIAS_FUNCTION(deepcopy_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo,
                      deepcopy_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT)

#endif
#ifdef VK_AMD_shader_core_properties2
void deepcopy_VkPhysicalDeviceShaderCoreProperties2AMD(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceShaderCoreProperties2AMD* from,
    VkPhysicalDeviceShaderCoreProperties2AMD* to);

#endif
#ifdef VK_AMD_device_coherent_memory
void deepcopy_VkPhysicalDeviceCoherentMemoryFeaturesAMD(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceCoherentMemoryFeaturesAMD* from,
    VkPhysicalDeviceCoherentMemoryFeaturesAMD* to);

#endif
#ifdef VK_EXT_shader_image_atomic_int64
void deepcopy_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* from,
    VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* to);

#endif
#ifdef VK_EXT_memory_budget
void deepcopy_VkPhysicalDeviceMemoryBudgetPropertiesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceMemoryBudgetPropertiesEXT* from,
    VkPhysicalDeviceMemoryBudgetPropertiesEXT* to);

#endif
#ifdef VK_EXT_memory_priority
void deepcopy_VkPhysicalDeviceMemoryPriorityFeaturesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceMemoryPriorityFeaturesEXT* from,
    VkPhysicalDeviceMemoryPriorityFeaturesEXT* to);

void deepcopy_VkMemoryPriorityAllocateInfoEXT(Allocator* alloc, VkStructureType rootType,
                                              const VkMemoryPriorityAllocateInfoEXT* from,
                                              VkMemoryPriorityAllocateInfoEXT* to);

#endif
#ifdef VK_NV_dedicated_allocation_image_aliasing
void deepcopy_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* from,
    VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* to);

#endif
#ifdef VK_EXT_buffer_device_address
void deepcopy_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* from,
    VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* to);

DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT,
                      deepcopy_VkPhysicalDeviceBufferAddressFeaturesEXT)

DEFINE_ALIAS_FUNCTION(deepcopy_VkBufferDeviceAddressInfo, deepcopy_VkBufferDeviceAddressInfoEXT)

void deepcopy_VkBufferDeviceAddressCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
                                                 const VkBufferDeviceAddressCreateInfoEXT* from,
                                                 VkBufferDeviceAddressCreateInfoEXT* to);

#endif
#ifdef VK_EXT_tooling_info
DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceToolProperties,
                      deepcopy_VkPhysicalDeviceToolPropertiesEXT)

#endif
#ifdef VK_EXT_separate_stencil_usage
DEFINE_ALIAS_FUNCTION(deepcopy_VkImageStencilUsageCreateInfo,
                      deepcopy_VkImageStencilUsageCreateInfoEXT)

#endif
#ifdef VK_EXT_validation_features
void deepcopy_VkValidationFeaturesEXT(Allocator* alloc, VkStructureType rootType,
                                      const VkValidationFeaturesEXT* from,
                                      VkValidationFeaturesEXT* to);

#endif
#ifdef VK_NV_cooperative_matrix
void deepcopy_VkCooperativeMatrixPropertiesNV(Allocator* alloc, VkStructureType rootType,
                                              const VkCooperativeMatrixPropertiesNV* from,
                                              VkCooperativeMatrixPropertiesNV* to);

void deepcopy_VkPhysicalDeviceCooperativeMatrixFeaturesNV(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceCooperativeMatrixFeaturesNV* from,
    VkPhysicalDeviceCooperativeMatrixFeaturesNV* to);

void deepcopy_VkPhysicalDeviceCooperativeMatrixPropertiesNV(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceCooperativeMatrixPropertiesNV* from,
    VkPhysicalDeviceCooperativeMatrixPropertiesNV* to);

#endif
#ifdef VK_NV_coverage_reduction_mode
void deepcopy_VkPhysicalDeviceCoverageReductionModeFeaturesNV(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceCoverageReductionModeFeaturesNV* from,
    VkPhysicalDeviceCoverageReductionModeFeaturesNV* to);

void deepcopy_VkPipelineCoverageReductionStateCreateInfoNV(
    Allocator* alloc, VkStructureType rootType,
    const VkPipelineCoverageReductionStateCreateInfoNV* from,
    VkPipelineCoverageReductionStateCreateInfoNV* to);

void deepcopy_VkFramebufferMixedSamplesCombinationNV(
    Allocator* alloc, VkStructureType rootType, const VkFramebufferMixedSamplesCombinationNV* from,
    VkFramebufferMixedSamplesCombinationNV* to);

#endif
#ifdef VK_EXT_fragment_shader_interlock
void deepcopy_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* from,
    VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* to);

#endif
#ifdef VK_EXT_ycbcr_image_arrays
void deepcopy_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* from,
    VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* to);

#endif
#ifdef VK_EXT_provoking_vertex
void deepcopy_VkPhysicalDeviceProvokingVertexFeaturesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceProvokingVertexFeaturesEXT* from,
    VkPhysicalDeviceProvokingVertexFeaturesEXT* to);

void deepcopy_VkPhysicalDeviceProvokingVertexPropertiesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceProvokingVertexPropertiesEXT* from,
    VkPhysicalDeviceProvokingVertexPropertiesEXT* to);

void deepcopy_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* from,
    VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* to);

#endif
#ifdef VK_EXT_full_screen_exclusive
void deepcopy_VkSurfaceFullScreenExclusiveInfoEXT(Allocator* alloc, VkStructureType rootType,
                                                  const VkSurfaceFullScreenExclusiveInfoEXT* from,
                                                  VkSurfaceFullScreenExclusiveInfoEXT* to);

void deepcopy_VkSurfaceCapabilitiesFullScreenExclusiveEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkSurfaceCapabilitiesFullScreenExclusiveEXT* from,
    VkSurfaceCapabilitiesFullScreenExclusiveEXT* to);

void deepcopy_VkSurfaceFullScreenExclusiveWin32InfoEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkSurfaceFullScreenExclusiveWin32InfoEXT* from,
    VkSurfaceFullScreenExclusiveWin32InfoEXT* to);

#endif
#ifdef VK_EXT_headless_surface
void deepcopy_VkHeadlessSurfaceCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
                                             const VkHeadlessSurfaceCreateInfoEXT* from,
                                             VkHeadlessSurfaceCreateInfoEXT* to);

#endif
#ifdef VK_EXT_line_rasterization
void deepcopy_VkPhysicalDeviceLineRasterizationFeaturesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceLineRasterizationFeaturesEXT* from,
    VkPhysicalDeviceLineRasterizationFeaturesEXT* to);

void deepcopy_VkPhysicalDeviceLineRasterizationPropertiesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceLineRasterizationPropertiesEXT* from,
    VkPhysicalDeviceLineRasterizationPropertiesEXT* to);

void deepcopy_VkPipelineRasterizationLineStateCreateInfoEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPipelineRasterizationLineStateCreateInfoEXT* from,
    VkPipelineRasterizationLineStateCreateInfoEXT* to);

#endif
#ifdef VK_EXT_shader_atomic_float
void deepcopy_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* from,
    VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* to);

#endif
#ifdef VK_EXT_host_query_reset
DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceHostQueryResetFeatures,
                      deepcopy_VkPhysicalDeviceHostQueryResetFeaturesEXT)

#endif
#ifdef VK_EXT_index_type_uint8
void deepcopy_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceIndexTypeUint8FeaturesEXT* from,
    VkPhysicalDeviceIndexTypeUint8FeaturesEXT* to);

#endif
#ifdef VK_EXT_extended_dynamic_state
void deepcopy_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* from,
    VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* to);

#endif
#ifdef VK_EXT_shader_atomic_float2
void deepcopy_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* from,
    VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* to);

#endif
#ifdef VK_EXT_surface_maintenance1
void deepcopy_VkSurfacePresentModeEXT(Allocator* alloc, VkStructureType rootType,
                                      const VkSurfacePresentModeEXT* from,
                                      VkSurfacePresentModeEXT* to);

void deepcopy_VkSurfacePresentScalingCapabilitiesEXT(
    Allocator* alloc, VkStructureType rootType, const VkSurfacePresentScalingCapabilitiesEXT* from,
    VkSurfacePresentScalingCapabilitiesEXT* to);

void deepcopy_VkSurfacePresentModeCompatibilityEXT(Allocator* alloc, VkStructureType rootType,
                                                   const VkSurfacePresentModeCompatibilityEXT* from,
                                                   VkSurfacePresentModeCompatibilityEXT* to);

#endif
#ifdef VK_EXT_swapchain_maintenance1
void deepcopy_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* from,
    VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* to);

void deepcopy_VkSwapchainPresentFenceInfoEXT(Allocator* alloc, VkStructureType rootType,
                                             const VkSwapchainPresentFenceInfoEXT* from,
                                             VkSwapchainPresentFenceInfoEXT* to);

void deepcopy_VkSwapchainPresentModesCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
                                                   const VkSwapchainPresentModesCreateInfoEXT* from,
                                                   VkSwapchainPresentModesCreateInfoEXT* to);

void deepcopy_VkSwapchainPresentModeInfoEXT(Allocator* alloc, VkStructureType rootType,
                                            const VkSwapchainPresentModeInfoEXT* from,
                                            VkSwapchainPresentModeInfoEXT* to);

void deepcopy_VkSwapchainPresentScalingCreateInfoEXT(
    Allocator* alloc, VkStructureType rootType, const VkSwapchainPresentScalingCreateInfoEXT* from,
    VkSwapchainPresentScalingCreateInfoEXT* to);

void deepcopy_VkReleaseSwapchainImagesInfoEXT(Allocator* alloc, VkStructureType rootType,
                                              const VkReleaseSwapchainImagesInfoEXT* from,
                                              VkReleaseSwapchainImagesInfoEXT* to);

#endif
#ifdef VK_EXT_shader_demote_to_helper_invocation
DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures,
                      deepcopy_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT)

#endif
#ifdef VK_NV_device_generated_commands
void deepcopy_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* from,
    VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* to);

void deepcopy_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* from,
    VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* to);

void deepcopy_VkGraphicsShaderGroupCreateInfoNV(Allocator* alloc, VkStructureType rootType,
                                                const VkGraphicsShaderGroupCreateInfoNV* from,
                                                VkGraphicsShaderGroupCreateInfoNV* to);

void deepcopy_VkGraphicsPipelineShaderGroupsCreateInfoNV(
    Allocator* alloc, VkStructureType rootType,
    const VkGraphicsPipelineShaderGroupsCreateInfoNV* from,
    VkGraphicsPipelineShaderGroupsCreateInfoNV* to);

void deepcopy_VkBindShaderGroupIndirectCommandNV(Allocator* alloc, VkStructureType rootType,
                                                 const VkBindShaderGroupIndirectCommandNV* from,
                                                 VkBindShaderGroupIndirectCommandNV* to);

void deepcopy_VkBindIndexBufferIndirectCommandNV(Allocator* alloc, VkStructureType rootType,
                                                 const VkBindIndexBufferIndirectCommandNV* from,
                                                 VkBindIndexBufferIndirectCommandNV* to);

void deepcopy_VkBindVertexBufferIndirectCommandNV(Allocator* alloc, VkStructureType rootType,
                                                  const VkBindVertexBufferIndirectCommandNV* from,
                                                  VkBindVertexBufferIndirectCommandNV* to);

void deepcopy_VkSetStateFlagsIndirectCommandNV(Allocator* alloc, VkStructureType rootType,
                                               const VkSetStateFlagsIndirectCommandNV* from,
                                               VkSetStateFlagsIndirectCommandNV* to);

void deepcopy_VkIndirectCommandsStreamNV(Allocator* alloc, VkStructureType rootType,
                                         const VkIndirectCommandsStreamNV* from,
                                         VkIndirectCommandsStreamNV* to);

void deepcopy_VkIndirectCommandsLayoutTokenNV(Allocator* alloc, VkStructureType rootType,
                                              const VkIndirectCommandsLayoutTokenNV* from,
                                              VkIndirectCommandsLayoutTokenNV* to);

void deepcopy_VkIndirectCommandsLayoutCreateInfoNV(Allocator* alloc, VkStructureType rootType,
                                                   const VkIndirectCommandsLayoutCreateInfoNV* from,
                                                   VkIndirectCommandsLayoutCreateInfoNV* to);

void deepcopy_VkGeneratedCommandsInfoNV(Allocator* alloc, VkStructureType rootType,
                                        const VkGeneratedCommandsInfoNV* from,
                                        VkGeneratedCommandsInfoNV* to);

void deepcopy_VkGeneratedCommandsMemoryRequirementsInfoNV(
    Allocator* alloc, VkStructureType rootType,
    const VkGeneratedCommandsMemoryRequirementsInfoNV* from,
    VkGeneratedCommandsMemoryRequirementsInfoNV* to);

#endif
#ifdef VK_NV_inherited_viewport_scissor
void deepcopy_VkPhysicalDeviceInheritedViewportScissorFeaturesNV(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceInheritedViewportScissorFeaturesNV* from,
    VkPhysicalDeviceInheritedViewportScissorFeaturesNV* to);

void deepcopy_VkCommandBufferInheritanceViewportScissorInfoNV(
    Allocator* alloc, VkStructureType rootType,
    const VkCommandBufferInheritanceViewportScissorInfoNV* from,
    VkCommandBufferInheritanceViewportScissorInfoNV* to);

#endif
#ifdef VK_EXT_texel_buffer_alignment
void deepcopy_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* from,
    VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* to);

DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceTexelBufferAlignmentProperties,
                      deepcopy_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT)

#endif
#ifdef VK_QCOM_render_pass_transform
void deepcopy_VkRenderPassTransformBeginInfoQCOM(Allocator* alloc, VkStructureType rootType,
                                                 const VkRenderPassTransformBeginInfoQCOM* from,
                                                 VkRenderPassTransformBeginInfoQCOM* to);

void deepcopy_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(
    Allocator* alloc, VkStructureType rootType,
    const VkCommandBufferInheritanceRenderPassTransformInfoQCOM* from,
    VkCommandBufferInheritanceRenderPassTransformInfoQCOM* to);

#endif
#ifdef VK_EXT_device_memory_report
void deepcopy_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* from,
    VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* to);

void deepcopy_VkDeviceMemoryReportCallbackDataEXT(Allocator* alloc, VkStructureType rootType,
                                                  const VkDeviceMemoryReportCallbackDataEXT* from,
                                                  VkDeviceMemoryReportCallbackDataEXT* to);

void deepcopy_VkDeviceDeviceMemoryReportCreateInfoEXT(
    Allocator* alloc, VkStructureType rootType, const VkDeviceDeviceMemoryReportCreateInfoEXT* from,
    VkDeviceDeviceMemoryReportCreateInfoEXT* to);

#endif
#ifdef VK_EXT_acquire_drm_display
#endif
#ifdef VK_EXT_robustness2
void deepcopy_VkPhysicalDeviceRobustness2FeaturesEXT(
    Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceRobustness2FeaturesEXT* from,
    VkPhysicalDeviceRobustness2FeaturesEXT* to);

void deepcopy_VkPhysicalDeviceRobustness2PropertiesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceRobustness2PropertiesEXT* from,
    VkPhysicalDeviceRobustness2PropertiesEXT* to);

#endif
#ifdef VK_EXT_custom_border_color
void deepcopy_VkSamplerCustomBorderColorCreateInfoEXT(
    Allocator* alloc, VkStructureType rootType, const VkSamplerCustomBorderColorCreateInfoEXT* from,
    VkSamplerCustomBorderColorCreateInfoEXT* to);

void deepcopy_VkPhysicalDeviceCustomBorderColorPropertiesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceCustomBorderColorPropertiesEXT* from,
    VkPhysicalDeviceCustomBorderColorPropertiesEXT* to);

void deepcopy_VkPhysicalDeviceCustomBorderColorFeaturesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceCustomBorderColorFeaturesEXT* from,
    VkPhysicalDeviceCustomBorderColorFeaturesEXT* to);

#endif
#ifdef VK_GOOGLE_user_type
#endif
#ifdef VK_NV_present_barrier
void deepcopy_VkPhysicalDevicePresentBarrierFeaturesNV(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDevicePresentBarrierFeaturesNV* from,
    VkPhysicalDevicePresentBarrierFeaturesNV* to);

void deepcopy_VkSurfaceCapabilitiesPresentBarrierNV(
    Allocator* alloc, VkStructureType rootType, const VkSurfaceCapabilitiesPresentBarrierNV* from,
    VkSurfaceCapabilitiesPresentBarrierNV* to);

void deepcopy_VkSwapchainPresentBarrierCreateInfoNV(
    Allocator* alloc, VkStructureType rootType, const VkSwapchainPresentBarrierCreateInfoNV* from,
    VkSwapchainPresentBarrierCreateInfoNV* to);

#endif
#ifdef VK_EXT_private_data
DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDevicePrivateDataFeatures,
                      deepcopy_VkPhysicalDevicePrivateDataFeaturesEXT)

DEFINE_ALIAS_FUNCTION(deepcopy_VkDevicePrivateDataCreateInfo,
                      deepcopy_VkDevicePrivateDataCreateInfoEXT)

DEFINE_ALIAS_FUNCTION(deepcopy_VkPrivateDataSlotCreateInfo, deepcopy_VkPrivateDataSlotCreateInfoEXT)

#endif
#ifdef VK_EXT_pipeline_creation_cache_control
DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDevicePipelineCreationCacheControlFeatures,
                      deepcopy_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT)

#endif
#ifdef VK_NV_device_diagnostics_config
void deepcopy_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceDiagnosticsConfigFeaturesNV* from,
    VkPhysicalDeviceDiagnosticsConfigFeaturesNV* to);

void deepcopy_VkDeviceDiagnosticsConfigCreateInfoNV(
    Allocator* alloc, VkStructureType rootType, const VkDeviceDiagnosticsConfigCreateInfoNV* from,
    VkDeviceDiagnosticsConfigCreateInfoNV* to);

#endif
#ifdef VK_QCOM_render_pass_store_ops
#endif
#ifdef VK_NV_low_latency
void deepcopy_VkQueryLowLatencySupportNV(Allocator* alloc, VkStructureType rootType,
                                         const VkQueryLowLatencySupportNV* from,
                                         VkQueryLowLatencySupportNV* to);

#endif
#ifdef VK_EXT_metal_objects
void deepcopy_VkExportMetalObjectCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
                                               const VkExportMetalObjectCreateInfoEXT* from,
                                               VkExportMetalObjectCreateInfoEXT* to);

void deepcopy_VkExportMetalObjectsInfoEXT(Allocator* alloc, VkStructureType rootType,
                                          const VkExportMetalObjectsInfoEXT* from,
                                          VkExportMetalObjectsInfoEXT* to);

void deepcopy_VkExportMetalDeviceInfoEXT(Allocator* alloc, VkStructureType rootType,
                                         const VkExportMetalDeviceInfoEXT* from,
                                         VkExportMetalDeviceInfoEXT* to);

void deepcopy_VkExportMetalCommandQueueInfoEXT(Allocator* alloc, VkStructureType rootType,
                                               const VkExportMetalCommandQueueInfoEXT* from,
                                               VkExportMetalCommandQueueInfoEXT* to);

void deepcopy_VkExportMetalBufferInfoEXT(Allocator* alloc, VkStructureType rootType,
                                         const VkExportMetalBufferInfoEXT* from,
                                         VkExportMetalBufferInfoEXT* to);

void deepcopy_VkImportMetalBufferInfoEXT(Allocator* alloc, VkStructureType rootType,
                                         const VkImportMetalBufferInfoEXT* from,
                                         VkImportMetalBufferInfoEXT* to);

void deepcopy_VkExportMetalTextureInfoEXT(Allocator* alloc, VkStructureType rootType,
                                          const VkExportMetalTextureInfoEXT* from,
                                          VkExportMetalTextureInfoEXT* to);

void deepcopy_VkImportMetalTextureInfoEXT(Allocator* alloc, VkStructureType rootType,
                                          const VkImportMetalTextureInfoEXT* from,
                                          VkImportMetalTextureInfoEXT* to);

void deepcopy_VkExportMetalIOSurfaceInfoEXT(Allocator* alloc, VkStructureType rootType,
                                            const VkExportMetalIOSurfaceInfoEXT* from,
                                            VkExportMetalIOSurfaceInfoEXT* to);

void deepcopy_VkImportMetalIOSurfaceInfoEXT(Allocator* alloc, VkStructureType rootType,
                                            const VkImportMetalIOSurfaceInfoEXT* from,
                                            VkImportMetalIOSurfaceInfoEXT* to);

void deepcopy_VkExportMetalSharedEventInfoEXT(Allocator* alloc, VkStructureType rootType,
                                              const VkExportMetalSharedEventInfoEXT* from,
                                              VkExportMetalSharedEventInfoEXT* to);

void deepcopy_VkImportMetalSharedEventInfoEXT(Allocator* alloc, VkStructureType rootType,
                                              const VkImportMetalSharedEventInfoEXT* from,
                                              VkImportMetalSharedEventInfoEXT* to);

#endif
#ifdef VK_EXT_descriptor_buffer
void deepcopy_VkPhysicalDeviceDescriptorBufferPropertiesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceDescriptorBufferPropertiesEXT* from,
    VkPhysicalDeviceDescriptorBufferPropertiesEXT* to);

void deepcopy_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT* from,
    VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT* to);

void deepcopy_VkPhysicalDeviceDescriptorBufferFeaturesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceDescriptorBufferFeaturesEXT* from,
    VkPhysicalDeviceDescriptorBufferFeaturesEXT* to);

void deepcopy_VkDescriptorAddressInfoEXT(Allocator* alloc, VkStructureType rootType,
                                         const VkDescriptorAddressInfoEXT* from,
                                         VkDescriptorAddressInfoEXT* to);

void deepcopy_VkDescriptorBufferBindingInfoEXT(Allocator* alloc, VkStructureType rootType,
                                               const VkDescriptorBufferBindingInfoEXT* from,
                                               VkDescriptorBufferBindingInfoEXT* to);

void deepcopy_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkDescriptorBufferBindingPushDescriptorBufferHandleEXT* from,
    VkDescriptorBufferBindingPushDescriptorBufferHandleEXT* to);

void deepcopy_VkDescriptorDataEXT(Allocator* alloc, VkStructureType rootType,
                                  const VkDescriptorDataEXT* from, VkDescriptorDataEXT* to);

void deepcopy_VkDescriptorGetInfoEXT(Allocator* alloc, VkStructureType rootType,
                                     const VkDescriptorGetInfoEXT* from,
                                     VkDescriptorGetInfoEXT* to);

void deepcopy_VkBufferCaptureDescriptorDataInfoEXT(Allocator* alloc, VkStructureType rootType,
                                                   const VkBufferCaptureDescriptorDataInfoEXT* from,
                                                   VkBufferCaptureDescriptorDataInfoEXT* to);

void deepcopy_VkImageCaptureDescriptorDataInfoEXT(Allocator* alloc, VkStructureType rootType,
                                                  const VkImageCaptureDescriptorDataInfoEXT* from,
                                                  VkImageCaptureDescriptorDataInfoEXT* to);

void deepcopy_VkImageViewCaptureDescriptorDataInfoEXT(
    Allocator* alloc, VkStructureType rootType, const VkImageViewCaptureDescriptorDataInfoEXT* from,
    VkImageViewCaptureDescriptorDataInfoEXT* to);

void deepcopy_VkSamplerCaptureDescriptorDataInfoEXT(
    Allocator* alloc, VkStructureType rootType, const VkSamplerCaptureDescriptorDataInfoEXT* from,
    VkSamplerCaptureDescriptorDataInfoEXT* to);

void deepcopy_VkOpaqueCaptureDescriptorDataCreateInfoEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkOpaqueCaptureDescriptorDataCreateInfoEXT* from,
    VkOpaqueCaptureDescriptorDataCreateInfoEXT* to);

void deepcopy_VkAccelerationStructureCaptureDescriptorDataInfoEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkAccelerationStructureCaptureDescriptorDataInfoEXT* from,
    VkAccelerationStructureCaptureDescriptorDataInfoEXT* to);

#endif
#ifdef VK_EXT_graphics_pipeline_library
void deepcopy_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* from,
    VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* to);

void deepcopy_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* from,
    VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* to);

void deepcopy_VkGraphicsPipelineLibraryCreateInfoEXT(
    Allocator* alloc, VkStructureType rootType, const VkGraphicsPipelineLibraryCreateInfoEXT* from,
    VkGraphicsPipelineLibraryCreateInfoEXT* to);

#endif
#ifdef VK_AMD_shader_early_and_late_fragment_tests
void deepcopy_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* from,
    VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* to);

#endif
#ifdef VK_NV_fragment_shading_rate_enums
void deepcopy_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* from,
    VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* to);

void deepcopy_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* from,
    VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* to);

void deepcopy_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(
    Allocator* alloc, VkStructureType rootType,
    const VkPipelineFragmentShadingRateEnumStateCreateInfoNV* from,
    VkPipelineFragmentShadingRateEnumStateCreateInfoNV* to);

#endif
#ifdef VK_NV_ray_tracing_motion_blur
void deepcopy_VkDeviceOrHostAddressConstKHR(Allocator* alloc, VkStructureType rootType,
                                            const VkDeviceOrHostAddressConstKHR* from,
                                            VkDeviceOrHostAddressConstKHR* to);

void deepcopy_VkAccelerationStructureGeometryMotionTrianglesDataNV(
    Allocator* alloc, VkStructureType rootType,
    const VkAccelerationStructureGeometryMotionTrianglesDataNV* from,
    VkAccelerationStructureGeometryMotionTrianglesDataNV* to);

void deepcopy_VkAccelerationStructureMotionInfoNV(Allocator* alloc, VkStructureType rootType,
                                                  const VkAccelerationStructureMotionInfoNV* from,
                                                  VkAccelerationStructureMotionInfoNV* to);

void deepcopy_VkAccelerationStructureMatrixMotionInstanceNV(
    Allocator* alloc, VkStructureType rootType,
    const VkAccelerationStructureMatrixMotionInstanceNV* from,
    VkAccelerationStructureMatrixMotionInstanceNV* to);

void deepcopy_VkSRTDataNV(Allocator* alloc, VkStructureType rootType, const VkSRTDataNV* from,
                          VkSRTDataNV* to);

void deepcopy_VkAccelerationStructureSRTMotionInstanceNV(
    Allocator* alloc, VkStructureType rootType,
    const VkAccelerationStructureSRTMotionInstanceNV* from,
    VkAccelerationStructureSRTMotionInstanceNV* to);

void deepcopy_VkAccelerationStructureMotionInstanceDataNV(
    Allocator* alloc, VkStructureType rootType,
    const VkAccelerationStructureMotionInstanceDataNV* from,
    VkAccelerationStructureMotionInstanceDataNV* to);

void deepcopy_VkAccelerationStructureMotionInstanceNV(
    Allocator* alloc, VkStructureType rootType, const VkAccelerationStructureMotionInstanceNV* from,
    VkAccelerationStructureMotionInstanceNV* to);

void deepcopy_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* from,
    VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* to);

#endif
#ifdef VK_EXT_ycbcr_2plane_444_formats
void deepcopy_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* from,
    VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* to);

#endif
#ifdef VK_EXT_fragment_density_map2
void deepcopy_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* from,
    VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* to);

void deepcopy_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* from,
    VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* to);

#endif
#ifdef VK_QCOM_rotated_copy_commands
void deepcopy_VkCopyCommandTransformInfoQCOM(Allocator* alloc, VkStructureType rootType,
                                             const VkCopyCommandTransformInfoQCOM* from,
                                             VkCopyCommandTransformInfoQCOM* to);

#endif
#ifdef VK_EXT_image_robustness
DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceImageRobustnessFeatures,
                      deepcopy_VkPhysicalDeviceImageRobustnessFeaturesEXT)

#endif
#ifdef VK_EXT_image_compression_control
void deepcopy_VkPhysicalDeviceImageCompressionControlFeaturesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceImageCompressionControlFeaturesEXT* from,
    VkPhysicalDeviceImageCompressionControlFeaturesEXT* to);

void deepcopy_VkImageCompressionControlEXT(Allocator* alloc, VkStructureType rootType,
                                           const VkImageCompressionControlEXT* from,
                                           VkImageCompressionControlEXT* to);

void deepcopy_VkSubresourceLayout2EXT(Allocator* alloc, VkStructureType rootType,
                                      const VkSubresourceLayout2EXT* from,
                                      VkSubresourceLayout2EXT* to);

void deepcopy_VkImageSubresource2EXT(Allocator* alloc, VkStructureType rootType,
                                     const VkImageSubresource2EXT* from,
                                     VkImageSubresource2EXT* to);

void deepcopy_VkImageCompressionPropertiesEXT(Allocator* alloc, VkStructureType rootType,
                                              const VkImageCompressionPropertiesEXT* from,
                                              VkImageCompressionPropertiesEXT* to);

#endif
#ifdef VK_EXT_attachment_feedback_loop_layout
void deepcopy_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* from,
    VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* to);

#endif
#ifdef VK_EXT_4444_formats
void deepcopy_VkPhysicalDevice4444FormatsFeaturesEXT(
    Allocator* alloc, VkStructureType rootType, const VkPhysicalDevice4444FormatsFeaturesEXT* from,
    VkPhysicalDevice4444FormatsFeaturesEXT* to);

#endif
#ifdef VK_EXT_device_fault
void deepcopy_VkPhysicalDeviceFaultFeaturesEXT(Allocator* alloc, VkStructureType rootType,
                                               const VkPhysicalDeviceFaultFeaturesEXT* from,
                                               VkPhysicalDeviceFaultFeaturesEXT* to);

void deepcopy_VkDeviceFaultCountsEXT(Allocator* alloc, VkStructureType rootType,
                                     const VkDeviceFaultCountsEXT* from,
                                     VkDeviceFaultCountsEXT* to);

void deepcopy_VkDeviceFaultAddressInfoEXT(Allocator* alloc, VkStructureType rootType,
                                          const VkDeviceFaultAddressInfoEXT* from,
                                          VkDeviceFaultAddressInfoEXT* to);

void deepcopy_VkDeviceFaultVendorInfoEXT(Allocator* alloc, VkStructureType rootType,
                                         const VkDeviceFaultVendorInfoEXT* from,
                                         VkDeviceFaultVendorInfoEXT* to);

void deepcopy_VkDeviceFaultInfoEXT(Allocator* alloc, VkStructureType rootType,
                                   const VkDeviceFaultInfoEXT* from, VkDeviceFaultInfoEXT* to);

void deepcopy_VkDeviceFaultVendorBinaryHeaderVersionOneEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkDeviceFaultVendorBinaryHeaderVersionOneEXT* from,
    VkDeviceFaultVendorBinaryHeaderVersionOneEXT* to);

#endif
#ifdef VK_ARM_rasterization_order_attachment_access
void deepcopy_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* from,
    VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* to);

DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT,
                      deepcopy_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM)

#endif
#ifdef VK_EXT_rgba10x6_formats
void deepcopy_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* from,
    VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* to);

#endif
#ifdef VK_NV_acquire_winrt_display
#endif
#ifdef VK_EXT_directfb_surface
void deepcopy_VkDirectFBSurfaceCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
                                             const VkDirectFBSurfaceCreateInfoEXT* from,
                                             VkDirectFBSurfaceCreateInfoEXT* to);

#endif
#ifdef VK_VALVE_mutable_descriptor_type
void deepcopy_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* from,
    VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* to);

DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT,
                      deepcopy_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE)

void deepcopy_VkMutableDescriptorTypeListEXT(Allocator* alloc, VkStructureType rootType,
                                             const VkMutableDescriptorTypeListEXT* from,
                                             VkMutableDescriptorTypeListEXT* to);

DEFINE_ALIAS_FUNCTION(deepcopy_VkMutableDescriptorTypeListEXT,
                      deepcopy_VkMutableDescriptorTypeListVALVE)

void deepcopy_VkMutableDescriptorTypeCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
                                                   const VkMutableDescriptorTypeCreateInfoEXT* from,
                                                   VkMutableDescriptorTypeCreateInfoEXT* to);

DEFINE_ALIAS_FUNCTION(deepcopy_VkMutableDescriptorTypeCreateInfoEXT,
                      deepcopy_VkMutableDescriptorTypeCreateInfoVALVE)

#endif
#ifdef VK_EXT_vertex_input_dynamic_state
void deepcopy_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* from,
    VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* to);

void deepcopy_VkVertexInputBindingDescription2EXT(Allocator* alloc, VkStructureType rootType,
                                                  const VkVertexInputBindingDescription2EXT* from,
                                                  VkVertexInputBindingDescription2EXT* to);

void deepcopy_VkVertexInputAttributeDescription2EXT(
    Allocator* alloc, VkStructureType rootType, const VkVertexInputAttributeDescription2EXT* from,
    VkVertexInputAttributeDescription2EXT* to);

#endif
#ifdef VK_EXT_physical_device_drm
void deepcopy_VkPhysicalDeviceDrmPropertiesEXT(Allocator* alloc, VkStructureType rootType,
                                               const VkPhysicalDeviceDrmPropertiesEXT* from,
                                               VkPhysicalDeviceDrmPropertiesEXT* to);

#endif
#ifdef VK_EXT_device_address_binding_report
void deepcopy_VkPhysicalDeviceAddressBindingReportFeaturesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceAddressBindingReportFeaturesEXT* from,
    VkPhysicalDeviceAddressBindingReportFeaturesEXT* to);

void deepcopy_VkDeviceAddressBindingCallbackDataEXT(
    Allocator* alloc, VkStructureType rootType, const VkDeviceAddressBindingCallbackDataEXT* from,
    VkDeviceAddressBindingCallbackDataEXT* to);

#endif
#ifdef VK_EXT_depth_clip_control
void deepcopy_VkPhysicalDeviceDepthClipControlFeaturesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceDepthClipControlFeaturesEXT* from,
    VkPhysicalDeviceDepthClipControlFeaturesEXT* to);

void deepcopy_VkPipelineViewportDepthClipControlCreateInfoEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPipelineViewportDepthClipControlCreateInfoEXT* from,
    VkPipelineViewportDepthClipControlCreateInfoEXT* to);

#endif
#ifdef VK_EXT_primitive_topology_list_restart
void deepcopy_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* from,
    VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* to);

#endif
#ifdef VK_FUCHSIA_external_memory
void deepcopy_VkImportMemoryZirconHandleInfoFUCHSIA(
    Allocator* alloc, VkStructureType rootType, const VkImportMemoryZirconHandleInfoFUCHSIA* from,
    VkImportMemoryZirconHandleInfoFUCHSIA* to);

void deepcopy_VkMemoryZirconHandlePropertiesFUCHSIA(
    Allocator* alloc, VkStructureType rootType, const VkMemoryZirconHandlePropertiesFUCHSIA* from,
    VkMemoryZirconHandlePropertiesFUCHSIA* to);

void deepcopy_VkMemoryGetZirconHandleInfoFUCHSIA(Allocator* alloc, VkStructureType rootType,
                                                 const VkMemoryGetZirconHandleInfoFUCHSIA* from,
                                                 VkMemoryGetZirconHandleInfoFUCHSIA* to);

#endif
#ifdef VK_FUCHSIA_external_semaphore
void deepcopy_VkImportSemaphoreZirconHandleInfoFUCHSIA(
    Allocator* alloc, VkStructureType rootType,
    const VkImportSemaphoreZirconHandleInfoFUCHSIA* from,
    VkImportSemaphoreZirconHandleInfoFUCHSIA* to);

void deepcopy_VkSemaphoreGetZirconHandleInfoFUCHSIA(
    Allocator* alloc, VkStructureType rootType, const VkSemaphoreGetZirconHandleInfoFUCHSIA* from,
    VkSemaphoreGetZirconHandleInfoFUCHSIA* to);

#endif
#ifdef VK_FUCHSIA_buffer_collection
void deepcopy_VkBufferCollectionCreateInfoFUCHSIA(Allocator* alloc, VkStructureType rootType,
                                                  const VkBufferCollectionCreateInfoFUCHSIA* from,
                                                  VkBufferCollectionCreateInfoFUCHSIA* to);

void deepcopy_VkImportMemoryBufferCollectionFUCHSIA(
    Allocator* alloc, VkStructureType rootType, const VkImportMemoryBufferCollectionFUCHSIA* from,
    VkImportMemoryBufferCollectionFUCHSIA* to);

void deepcopy_VkBufferCollectionImageCreateInfoFUCHSIA(
    Allocator* alloc, VkStructureType rootType,
    const VkBufferCollectionImageCreateInfoFUCHSIA* from,
    VkBufferCollectionImageCreateInfoFUCHSIA* to);

void deepcopy_VkBufferCollectionConstraintsInfoFUCHSIA(
    Allocator* alloc, VkStructureType rootType,
    const VkBufferCollectionConstraintsInfoFUCHSIA* from,
    VkBufferCollectionConstraintsInfoFUCHSIA* to);

void deepcopy_VkBufferConstraintsInfoFUCHSIA(Allocator* alloc, VkStructureType rootType,
                                             const VkBufferConstraintsInfoFUCHSIA* from,
                                             VkBufferConstraintsInfoFUCHSIA* to);

void deepcopy_VkBufferCollectionBufferCreateInfoFUCHSIA(
    Allocator* alloc, VkStructureType rootType,
    const VkBufferCollectionBufferCreateInfoFUCHSIA* from,
    VkBufferCollectionBufferCreateInfoFUCHSIA* to);

void deepcopy_VkSysmemColorSpaceFUCHSIA(Allocator* alloc, VkStructureType rootType,
                                        const VkSysmemColorSpaceFUCHSIA* from,
                                        VkSysmemColorSpaceFUCHSIA* to);

void deepcopy_VkBufferCollectionPropertiesFUCHSIA(Allocator* alloc, VkStructureType rootType,
                                                  const VkBufferCollectionPropertiesFUCHSIA* from,
                                                  VkBufferCollectionPropertiesFUCHSIA* to);

void deepcopy_VkImageFormatConstraintsInfoFUCHSIA(Allocator* alloc, VkStructureType rootType,
                                                  const VkImageFormatConstraintsInfoFUCHSIA* from,
                                                  VkImageFormatConstraintsInfoFUCHSIA* to);

void deepcopy_VkImageConstraintsInfoFUCHSIA(Allocator* alloc, VkStructureType rootType,
                                            const VkImageConstraintsInfoFUCHSIA* from,
                                            VkImageConstraintsInfoFUCHSIA* to);

#endif
#ifdef VK_HUAWEI_subpass_shading
void deepcopy_VkSubpassShadingPipelineCreateInfoHUAWEI(
    Allocator* alloc, VkStructureType rootType,
    const VkSubpassShadingPipelineCreateInfoHUAWEI* from,
    VkSubpassShadingPipelineCreateInfoHUAWEI* to);

void deepcopy_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* from,
    VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* to);

void deepcopy_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI* from,
    VkPhysicalDeviceSubpassShadingPropertiesHUAWEI* to);

#endif
#ifdef VK_HUAWEI_invocation_mask
void deepcopy_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* from,
    VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* to);

#endif
#ifdef VK_NV_external_memory_rdma
void deepcopy_VkMemoryGetRemoteAddressInfoNV(Allocator* alloc, VkStructureType rootType,
                                             const VkMemoryGetRemoteAddressInfoNV* from,
                                             VkMemoryGetRemoteAddressInfoNV* to);

void deepcopy_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* from,
    VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* to);

#endif
#ifdef VK_EXT_pipeline_properties
DEFINE_ALIAS_FUNCTION(deepcopy_VkPipelineInfoKHR, deepcopy_VkPipelineInfoEXT)

void deepcopy_VkPipelinePropertiesIdentifierEXT(Allocator* alloc, VkStructureType rootType,
                                                const VkPipelinePropertiesIdentifierEXT* from,
                                                VkPipelinePropertiesIdentifierEXT* to);

void deepcopy_VkPhysicalDevicePipelinePropertiesFeaturesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDevicePipelinePropertiesFeaturesEXT* from,
    VkPhysicalDevicePipelinePropertiesFeaturesEXT* to);

#endif
#ifdef VK_EXT_multisampled_render_to_single_sampled
void deepcopy_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* from,
    VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* to);

void deepcopy_VkSubpassResolvePerformanceQueryEXT(Allocator* alloc, VkStructureType rootType,
                                                  const VkSubpassResolvePerformanceQueryEXT* from,
                                                  VkSubpassResolvePerformanceQueryEXT* to);

void deepcopy_VkMultisampledRenderToSingleSampledInfoEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkMultisampledRenderToSingleSampledInfoEXT* from,
    VkMultisampledRenderToSingleSampledInfoEXT* to);

#endif
#ifdef VK_EXT_extended_dynamic_state2
void deepcopy_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* from,
    VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* to);

#endif
#ifdef VK_QNX_screen_surface
void deepcopy_VkScreenSurfaceCreateInfoQNX(Allocator* alloc, VkStructureType rootType,
                                           const VkScreenSurfaceCreateInfoQNX* from,
                                           VkScreenSurfaceCreateInfoQNX* to);

#endif
#ifdef VK_EXT_color_write_enable
void deepcopy_VkPhysicalDeviceColorWriteEnableFeaturesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceColorWriteEnableFeaturesEXT* from,
    VkPhysicalDeviceColorWriteEnableFeaturesEXT* to);

void deepcopy_VkPipelineColorWriteCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
                                                const VkPipelineColorWriteCreateInfoEXT* from,
                                                VkPipelineColorWriteCreateInfoEXT* to);

#endif
#ifdef VK_EXT_primitives_generated_query
void deepcopy_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* from,
    VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* to);

#endif
#ifdef VK_GOOGLE_gfxstream
void deepcopy_VkImportColorBufferGOOGLE(Allocator* alloc, VkStructureType rootType,
                                        const VkImportColorBufferGOOGLE* from,
                                        VkImportColorBufferGOOGLE* to);

void deepcopy_VkImportBufferGOOGLE(Allocator* alloc, VkStructureType rootType,
                                   const VkImportBufferGOOGLE* from, VkImportBufferGOOGLE* to);

void deepcopy_VkCreateBlobGOOGLE(Allocator* alloc, VkStructureType rootType,
                                 const VkCreateBlobGOOGLE* from, VkCreateBlobGOOGLE* to);

#endif
#ifdef VK_EXT_global_priority_query
DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR,
                      deepcopy_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT)

DEFINE_ALIAS_FUNCTION(deepcopy_VkQueueFamilyGlobalPriorityPropertiesKHR,
                      deepcopy_VkQueueFamilyGlobalPriorityPropertiesEXT)

#endif
#ifdef VK_EXT_image_view_min_lod
void deepcopy_VkPhysicalDeviceImageViewMinLodFeaturesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceImageViewMinLodFeaturesEXT* from,
    VkPhysicalDeviceImageViewMinLodFeaturesEXT* to);

void deepcopy_VkImageViewMinLodCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
                                             const VkImageViewMinLodCreateInfoEXT* from,
                                             VkImageViewMinLodCreateInfoEXT* to);

#endif
#ifdef VK_EXT_multi_draw
void deepcopy_VkPhysicalDeviceMultiDrawFeaturesEXT(Allocator* alloc, VkStructureType rootType,
                                                   const VkPhysicalDeviceMultiDrawFeaturesEXT* from,
                                                   VkPhysicalDeviceMultiDrawFeaturesEXT* to);

void deepcopy_VkPhysicalDeviceMultiDrawPropertiesEXT(
    Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceMultiDrawPropertiesEXT* from,
    VkPhysicalDeviceMultiDrawPropertiesEXT* to);

void deepcopy_VkMultiDrawInfoEXT(Allocator* alloc, VkStructureType rootType,
                                 const VkMultiDrawInfoEXT* from, VkMultiDrawInfoEXT* to);

void deepcopy_VkMultiDrawIndexedInfoEXT(Allocator* alloc, VkStructureType rootType,
                                        const VkMultiDrawIndexedInfoEXT* from,
                                        VkMultiDrawIndexedInfoEXT* to);

#endif
#ifdef VK_EXT_image_2d_view_of_3d
void deepcopy_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* from,
    VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* to);

#endif
#ifdef VK_EXT_shader_tile_image
void deepcopy_VkPhysicalDeviceShaderTileImageFeaturesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceShaderTileImageFeaturesEXT* from,
    VkPhysicalDeviceShaderTileImageFeaturesEXT* to);

void deepcopy_VkPhysicalDeviceShaderTileImagePropertiesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceShaderTileImagePropertiesEXT* from,
    VkPhysicalDeviceShaderTileImagePropertiesEXT* to);

#endif
#ifdef VK_EXT_opacity_micromap
void deepcopy_VkMicromapUsageEXT(Allocator* alloc, VkStructureType rootType,
                                 const VkMicromapUsageEXT* from, VkMicromapUsageEXT* to);

void deepcopy_VkDeviceOrHostAddressKHR(Allocator* alloc, VkStructureType rootType,
                                       const VkDeviceOrHostAddressKHR* from,
                                       VkDeviceOrHostAddressKHR* to);

void deepcopy_VkMicromapBuildInfoEXT(Allocator* alloc, VkStructureType rootType,
                                     const VkMicromapBuildInfoEXT* from,
                                     VkMicromapBuildInfoEXT* to);

void deepcopy_VkMicromapCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
                                      const VkMicromapCreateInfoEXT* from,
                                      VkMicromapCreateInfoEXT* to);

void deepcopy_VkPhysicalDeviceOpacityMicromapFeaturesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceOpacityMicromapFeaturesEXT* from,
    VkPhysicalDeviceOpacityMicromapFeaturesEXT* to);

void deepcopy_VkPhysicalDeviceOpacityMicromapPropertiesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceOpacityMicromapPropertiesEXT* from,
    VkPhysicalDeviceOpacityMicromapPropertiesEXT* to);

void deepcopy_VkMicromapVersionInfoEXT(Allocator* alloc, VkStructureType rootType,
                                       const VkMicromapVersionInfoEXT* from,
                                       VkMicromapVersionInfoEXT* to);

void deepcopy_VkCopyMicromapToMemoryInfoEXT(Allocator* alloc, VkStructureType rootType,
                                            const VkCopyMicromapToMemoryInfoEXT* from,
                                            VkCopyMicromapToMemoryInfoEXT* to);

void deepcopy_VkCopyMemoryToMicromapInfoEXT(Allocator* alloc, VkStructureType rootType,
                                            const VkCopyMemoryToMicromapInfoEXT* from,
                                            VkCopyMemoryToMicromapInfoEXT* to);

void deepcopy_VkCopyMicromapInfoEXT(Allocator* alloc, VkStructureType rootType,
                                    const VkCopyMicromapInfoEXT* from, VkCopyMicromapInfoEXT* to);

void deepcopy_VkMicromapBuildSizesInfoEXT(Allocator* alloc, VkStructureType rootType,
                                          const VkMicromapBuildSizesInfoEXT* from,
                                          VkMicromapBuildSizesInfoEXT* to);

void deepcopy_VkAccelerationStructureTrianglesOpacityMicromapEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkAccelerationStructureTrianglesOpacityMicromapEXT* from,
    VkAccelerationStructureTrianglesOpacityMicromapEXT* to);

void deepcopy_VkMicromapTriangleEXT(Allocator* alloc, VkStructureType rootType,
                                    const VkMicromapTriangleEXT* from, VkMicromapTriangleEXT* to);

#endif
#ifdef VK_NV_displacement_micromap
void deepcopy_VkPhysicalDeviceDisplacementMicromapFeaturesNV(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceDisplacementMicromapFeaturesNV* from,
    VkPhysicalDeviceDisplacementMicromapFeaturesNV* to);

void deepcopy_VkPhysicalDeviceDisplacementMicromapPropertiesNV(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceDisplacementMicromapPropertiesNV* from,
    VkPhysicalDeviceDisplacementMicromapPropertiesNV* to);

void deepcopy_VkAccelerationStructureTrianglesDisplacementMicromapNV(
    Allocator* alloc, VkStructureType rootType,
    const VkAccelerationStructureTrianglesDisplacementMicromapNV* from,
    VkAccelerationStructureTrianglesDisplacementMicromapNV* to);

#endif
#ifdef VK_EXT_load_store_op_none
#endif
#ifdef VK_HUAWEI_cluster_culling_shader
void deepcopy_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* from,
    VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* to);

void deepcopy_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI* from,
    VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI* to);

#endif
#ifdef VK_EXT_border_color_swizzle
void deepcopy_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* from,
    VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* to);

void deepcopy_VkSamplerBorderColorComponentMappingCreateInfoEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkSamplerBorderColorComponentMappingCreateInfoEXT* from,
    VkSamplerBorderColorComponentMappingCreateInfoEXT* to);

#endif
#ifdef VK_EXT_pageable_device_local_memory
void deepcopy_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* from,
    VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* to);

#endif
#ifdef VK_ARM_shader_core_properties
void deepcopy_VkPhysicalDeviceShaderCorePropertiesARM(
    Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceShaderCorePropertiesARM* from,
    VkPhysicalDeviceShaderCorePropertiesARM* to);

#endif
#ifdef VK_EXT_image_sliced_view_of_3d
void deepcopy_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* from,
    VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* to);

void deepcopy_VkImageViewSlicedCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
                                             const VkImageViewSlicedCreateInfoEXT* from,
                                             VkImageViewSlicedCreateInfoEXT* to);

#endif
#ifdef VK_VALVE_descriptor_set_host_mapping
void deepcopy_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* from,
    VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* to);

void deepcopy_VkDescriptorSetBindingReferenceVALVE(Allocator* alloc, VkStructureType rootType,
                                                   const VkDescriptorSetBindingReferenceVALVE* from,
                                                   VkDescriptorSetBindingReferenceVALVE* to);

void deepcopy_VkDescriptorSetLayoutHostMappingInfoVALVE(
    Allocator* alloc, VkStructureType rootType,
    const VkDescriptorSetLayoutHostMappingInfoVALVE* from,
    VkDescriptorSetLayoutHostMappingInfoVALVE* to);

#endif
#ifdef VK_EXT_depth_clamp_zero_one
void deepcopy_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* from,
    VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* to);

#endif
#ifdef VK_EXT_non_seamless_cube_map
void deepcopy_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* from,
    VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* to);

#endif
#ifdef VK_QCOM_fragment_density_map_offset
void deepcopy_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* from,
    VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* to);

void deepcopy_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* from,
    VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* to);

void deepcopy_VkSubpassFragmentDensityMapOffsetEndInfoQCOM(
    Allocator* alloc, VkStructureType rootType,
    const VkSubpassFragmentDensityMapOffsetEndInfoQCOM* from,
    VkSubpassFragmentDensityMapOffsetEndInfoQCOM* to);

#endif
#ifdef VK_NV_copy_memory_indirect
void deepcopy_VkCopyMemoryIndirectCommandNV(Allocator* alloc, VkStructureType rootType,
                                            const VkCopyMemoryIndirectCommandNV* from,
                                            VkCopyMemoryIndirectCommandNV* to);

void deepcopy_VkCopyMemoryToImageIndirectCommandNV(Allocator* alloc, VkStructureType rootType,
                                                   const VkCopyMemoryToImageIndirectCommandNV* from,
                                                   VkCopyMemoryToImageIndirectCommandNV* to);

void deepcopy_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV* from,
    VkPhysicalDeviceCopyMemoryIndirectFeaturesNV* to);

void deepcopy_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV* from,
    VkPhysicalDeviceCopyMemoryIndirectPropertiesNV* to);

#endif
#ifdef VK_NV_memory_decompression
void deepcopy_VkDecompressMemoryRegionNV(Allocator* alloc, VkStructureType rootType,
                                         const VkDecompressMemoryRegionNV* from,
                                         VkDecompressMemoryRegionNV* to);

void deepcopy_VkPhysicalDeviceMemoryDecompressionFeaturesNV(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceMemoryDecompressionFeaturesNV* from,
    VkPhysicalDeviceMemoryDecompressionFeaturesNV* to);

void deepcopy_VkPhysicalDeviceMemoryDecompressionPropertiesNV(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceMemoryDecompressionPropertiesNV* from,
    VkPhysicalDeviceMemoryDecompressionPropertiesNV* to);

#endif
#ifdef VK_NV_linear_color_attachment
void deepcopy_VkPhysicalDeviceLinearColorAttachmentFeaturesNV(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceLinearColorAttachmentFeaturesNV* from,
    VkPhysicalDeviceLinearColorAttachmentFeaturesNV* to);

#endif
#ifdef VK_GOOGLE_surfaceless_query
#endif
#ifdef VK_EXT_image_compression_control_swapchain
void deepcopy_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* from,
    VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* to);

#endif
#ifdef VK_QCOM_image_processing
void deepcopy_VkImageViewSampleWeightCreateInfoQCOM(
    Allocator* alloc, VkStructureType rootType, const VkImageViewSampleWeightCreateInfoQCOM* from,
    VkImageViewSampleWeightCreateInfoQCOM* to);

void deepcopy_VkPhysicalDeviceImageProcessingFeaturesQCOM(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceImageProcessingFeaturesQCOM* from,
    VkPhysicalDeviceImageProcessingFeaturesQCOM* to);

void deepcopy_VkPhysicalDeviceImageProcessingPropertiesQCOM(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceImageProcessingPropertiesQCOM* from,
    VkPhysicalDeviceImageProcessingPropertiesQCOM* to);

#endif
#ifdef VK_EXT_extended_dynamic_state3
void deepcopy_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* from,
    VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* to);

void deepcopy_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT* from,
    VkPhysicalDeviceExtendedDynamicState3PropertiesEXT* to);

void deepcopy_VkColorBlendEquationEXT(Allocator* alloc, VkStructureType rootType,
                                      const VkColorBlendEquationEXT* from,
                                      VkColorBlendEquationEXT* to);

void deepcopy_VkColorBlendAdvancedEXT(Allocator* alloc, VkStructureType rootType,
                                      const VkColorBlendAdvancedEXT* from,
                                      VkColorBlendAdvancedEXT* to);

#endif
#ifdef VK_EXT_subpass_merge_feedback
void deepcopy_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* from,
    VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* to);

void deepcopy_VkRenderPassCreationControlEXT(Allocator* alloc, VkStructureType rootType,
                                             const VkRenderPassCreationControlEXT* from,
                                             VkRenderPassCreationControlEXT* to);

void deepcopy_VkRenderPassCreationFeedbackInfoEXT(Allocator* alloc, VkStructureType rootType,
                                                  const VkRenderPassCreationFeedbackInfoEXT* from,
                                                  VkRenderPassCreationFeedbackInfoEXT* to);

void deepcopy_VkRenderPassCreationFeedbackCreateInfoEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkRenderPassCreationFeedbackCreateInfoEXT* from,
    VkRenderPassCreationFeedbackCreateInfoEXT* to);

void deepcopy_VkRenderPassSubpassFeedbackInfoEXT(Allocator* alloc, VkStructureType rootType,
                                                 const VkRenderPassSubpassFeedbackInfoEXT* from,
                                                 VkRenderPassSubpassFeedbackInfoEXT* to);

void deepcopy_VkRenderPassSubpassFeedbackCreateInfoEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkRenderPassSubpassFeedbackCreateInfoEXT* from,
    VkRenderPassSubpassFeedbackCreateInfoEXT* to);

#endif
#ifdef VK_LUNARG_direct_driver_loading
void deepcopy_VkDirectDriverLoadingInfoLUNARG(Allocator* alloc, VkStructureType rootType,
                                              const VkDirectDriverLoadingInfoLUNARG* from,
                                              VkDirectDriverLoadingInfoLUNARG* to);

void deepcopy_VkDirectDriverLoadingListLUNARG(Allocator* alloc, VkStructureType rootType,
                                              const VkDirectDriverLoadingListLUNARG* from,
                                              VkDirectDriverLoadingListLUNARG* to);

#endif
#ifdef VK_EXT_shader_module_identifier
void deepcopy_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* from,
    VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* to);

void deepcopy_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT* from,
    VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT* to);

void deepcopy_VkPipelineShaderStageModuleIdentifierCreateInfoEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPipelineShaderStageModuleIdentifierCreateInfoEXT* from,
    VkPipelineShaderStageModuleIdentifierCreateInfoEXT* to);

void deepcopy_VkShaderModuleIdentifierEXT(Allocator* alloc, VkStructureType rootType,
                                          const VkShaderModuleIdentifierEXT* from,
                                          VkShaderModuleIdentifierEXT* to);

#endif
#ifdef VK_EXT_rasterization_order_attachment_access
#endif
#ifdef VK_NV_optical_flow
void deepcopy_VkPhysicalDeviceOpticalFlowFeaturesNV(
    Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceOpticalFlowFeaturesNV* from,
    VkPhysicalDeviceOpticalFlowFeaturesNV* to);

void deepcopy_VkPhysicalDeviceOpticalFlowPropertiesNV(
    Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceOpticalFlowPropertiesNV* from,
    VkPhysicalDeviceOpticalFlowPropertiesNV* to);

void deepcopy_VkOpticalFlowImageFormatInfoNV(Allocator* alloc, VkStructureType rootType,
                                             const VkOpticalFlowImageFormatInfoNV* from,
                                             VkOpticalFlowImageFormatInfoNV* to);

void deepcopy_VkOpticalFlowImageFormatPropertiesNV(Allocator* alloc, VkStructureType rootType,
                                                   const VkOpticalFlowImageFormatPropertiesNV* from,
                                                   VkOpticalFlowImageFormatPropertiesNV* to);

void deepcopy_VkOpticalFlowSessionCreateInfoNV(Allocator* alloc, VkStructureType rootType,
                                               const VkOpticalFlowSessionCreateInfoNV* from,
                                               VkOpticalFlowSessionCreateInfoNV* to);

void deepcopy_VkOpticalFlowSessionCreatePrivateDataInfoNV(
    Allocator* alloc, VkStructureType rootType,
    const VkOpticalFlowSessionCreatePrivateDataInfoNV* from,
    VkOpticalFlowSessionCreatePrivateDataInfoNV* to);

void deepcopy_VkOpticalFlowExecuteInfoNV(Allocator* alloc, VkStructureType rootType,
                                         const VkOpticalFlowExecuteInfoNV* from,
                                         VkOpticalFlowExecuteInfoNV* to);

#endif
#ifdef VK_EXT_legacy_dithering
void deepcopy_VkPhysicalDeviceLegacyDitheringFeaturesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceLegacyDitheringFeaturesEXT* from,
    VkPhysicalDeviceLegacyDitheringFeaturesEXT* to);

#endif
#ifdef VK_EXT_pipeline_protected_access
void deepcopy_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* from,
    VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* to);

#endif
#ifdef VK_EXT_shader_object
void deepcopy_VkPhysicalDeviceShaderObjectFeaturesEXT(
    Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceShaderObjectFeaturesEXT* from,
    VkPhysicalDeviceShaderObjectFeaturesEXT* to);

void deepcopy_VkPhysicalDeviceShaderObjectPropertiesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceShaderObjectPropertiesEXT* from,
    VkPhysicalDeviceShaderObjectPropertiesEXT* to);

void deepcopy_VkShaderCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
                                    const VkShaderCreateInfoEXT* from, VkShaderCreateInfoEXT* to);

DEFINE_ALIAS_FUNCTION(deepcopy_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo,
                      deepcopy_VkShaderRequiredSubgroupSizeCreateInfoEXT)

#endif
#ifdef VK_QCOM_tile_properties
void deepcopy_VkPhysicalDeviceTilePropertiesFeaturesQCOM(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceTilePropertiesFeaturesQCOM* from,
    VkPhysicalDeviceTilePropertiesFeaturesQCOM* to);

void deepcopy_VkTilePropertiesQCOM(Allocator* alloc, VkStructureType rootType,
                                   const VkTilePropertiesQCOM* from, VkTilePropertiesQCOM* to);

#endif
#ifdef VK_SEC_amigo_profiling
void deepcopy_VkPhysicalDeviceAmigoProfilingFeaturesSEC(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceAmigoProfilingFeaturesSEC* from,
    VkPhysicalDeviceAmigoProfilingFeaturesSEC* to);

void deepcopy_VkAmigoProfilingSubmitInfoSEC(Allocator* alloc, VkStructureType rootType,
                                            const VkAmigoProfilingSubmitInfoSEC* from,
                                            VkAmigoProfilingSubmitInfoSEC* to);

#endif
#ifdef VK_QCOM_multiview_per_view_viewports
void deepcopy_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* from,
    VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* to);

#endif
#ifdef VK_NV_ray_tracing_invocation_reorder
void deepcopy_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV* from,
    VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV* to);

void deepcopy_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* from,
    VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* to);

#endif
#ifdef VK_EXT_mutable_descriptor_type
#endif
#ifdef VK_ARM_shader_core_builtins
void deepcopy_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* from,
    VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* to);

void deepcopy_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM* from,
    VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM* to);

#endif
#ifdef VK_EXT_pipeline_library_group_handles
void deepcopy_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* from,
    VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* to);

#endif
#ifdef VK_QCOM_multiview_per_view_render_areas
void deepcopy_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* from,
    VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* to);

void deepcopy_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM(
    Allocator* alloc, VkStructureType rootType,
    const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM* from,
    VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM* to);

#endif
#ifdef VK_EXT_attachment_feedback_loop_dynamic_state
void deepcopy_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* from,
    VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* to);

#endif
#ifdef VK_KHR_acceleration_structure
void deepcopy_VkAccelerationStructureBuildRangeInfoKHR(
    Allocator* alloc, VkStructureType rootType,
    const VkAccelerationStructureBuildRangeInfoKHR* from,
    VkAccelerationStructureBuildRangeInfoKHR* to);

void deepcopy_VkAccelerationStructureGeometryTrianglesDataKHR(
    Allocator* alloc, VkStructureType rootType,
    const VkAccelerationStructureGeometryTrianglesDataKHR* from,
    VkAccelerationStructureGeometryTrianglesDataKHR* to);

void deepcopy_VkAccelerationStructureGeometryAabbsDataKHR(
    Allocator* alloc, VkStructureType rootType,
    const VkAccelerationStructureGeometryAabbsDataKHR* from,
    VkAccelerationStructureGeometryAabbsDataKHR* to);

void deepcopy_VkAccelerationStructureGeometryInstancesDataKHR(
    Allocator* alloc, VkStructureType rootType,
    const VkAccelerationStructureGeometryInstancesDataKHR* from,
    VkAccelerationStructureGeometryInstancesDataKHR* to);

void deepcopy_VkAccelerationStructureGeometryDataKHR(
    Allocator* alloc, VkStructureType rootType, const VkAccelerationStructureGeometryDataKHR* from,
    VkAccelerationStructureGeometryDataKHR* to);

void deepcopy_VkAccelerationStructureGeometryKHR(Allocator* alloc, VkStructureType rootType,
                                                 const VkAccelerationStructureGeometryKHR* from,
                                                 VkAccelerationStructureGeometryKHR* to);

void deepcopy_VkAccelerationStructureBuildGeometryInfoKHR(
    Allocator* alloc, VkStructureType rootType,
    const VkAccelerationStructureBuildGeometryInfoKHR* from,
    VkAccelerationStructureBuildGeometryInfoKHR* to);

void deepcopy_VkAccelerationStructureCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
                                                   const VkAccelerationStructureCreateInfoKHR* from,
                                                   VkAccelerationStructureCreateInfoKHR* to);

void deepcopy_VkWriteDescriptorSetAccelerationStructureKHR(
    Allocator* alloc, VkStructureType rootType,
    const VkWriteDescriptorSetAccelerationStructureKHR* from,
    VkWriteDescriptorSetAccelerationStructureKHR* to);

void deepcopy_VkPhysicalDeviceAccelerationStructureFeaturesKHR(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceAccelerationStructureFeaturesKHR* from,
    VkPhysicalDeviceAccelerationStructureFeaturesKHR* to);

void deepcopy_VkPhysicalDeviceAccelerationStructurePropertiesKHR(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceAccelerationStructurePropertiesKHR* from,
    VkPhysicalDeviceAccelerationStructurePropertiesKHR* to);

void deepcopy_VkAccelerationStructureDeviceAddressInfoKHR(
    Allocator* alloc, VkStructureType rootType,
    const VkAccelerationStructureDeviceAddressInfoKHR* from,
    VkAccelerationStructureDeviceAddressInfoKHR* to);

void deepcopy_VkAccelerationStructureVersionInfoKHR(
    Allocator* alloc, VkStructureType rootType, const VkAccelerationStructureVersionInfoKHR* from,
    VkAccelerationStructureVersionInfoKHR* to);

void deepcopy_VkCopyAccelerationStructureToMemoryInfoKHR(
    Allocator* alloc, VkStructureType rootType,
    const VkCopyAccelerationStructureToMemoryInfoKHR* from,
    VkCopyAccelerationStructureToMemoryInfoKHR* to);

void deepcopy_VkCopyMemoryToAccelerationStructureInfoKHR(
    Allocator* alloc, VkStructureType rootType,
    const VkCopyMemoryToAccelerationStructureInfoKHR* from,
    VkCopyMemoryToAccelerationStructureInfoKHR* to);

void deepcopy_VkCopyAccelerationStructureInfoKHR(Allocator* alloc, VkStructureType rootType,
                                                 const VkCopyAccelerationStructureInfoKHR* from,
                                                 VkCopyAccelerationStructureInfoKHR* to);

void deepcopy_VkAccelerationStructureBuildSizesInfoKHR(
    Allocator* alloc, VkStructureType rootType,
    const VkAccelerationStructureBuildSizesInfoKHR* from,
    VkAccelerationStructureBuildSizesInfoKHR* to);

#endif
#ifdef VK_KHR_ray_tracing_pipeline
void deepcopy_VkRayTracingShaderGroupCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
                                                   const VkRayTracingShaderGroupCreateInfoKHR* from,
                                                   VkRayTracingShaderGroupCreateInfoKHR* to);

void deepcopy_VkRayTracingPipelineInterfaceCreateInfoKHR(
    Allocator* alloc, VkStructureType rootType,
    const VkRayTracingPipelineInterfaceCreateInfoKHR* from,
    VkRayTracingPipelineInterfaceCreateInfoKHR* to);

void deepcopy_VkRayTracingPipelineCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
                                                const VkRayTracingPipelineCreateInfoKHR* from,
                                                VkRayTracingPipelineCreateInfoKHR* to);

void deepcopy_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceRayTracingPipelineFeaturesKHR* from,
    VkPhysicalDeviceRayTracingPipelineFeaturesKHR* to);

void deepcopy_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
    Allocator* alloc, VkStructureType rootType,
    const VkPhysicalDeviceRayTracingPipelinePropertiesKHR* from,
    VkPhysicalDeviceRayTracingPipelinePropertiesKHR* to);

void deepcopy_VkStridedDeviceAddressRegionKHR(Allocator* alloc, VkStructureType rootType,
                                              const VkStridedDeviceAddressRegionKHR* from,
                                              VkStridedDeviceAddressRegionKHR* to);

void deepcopy_VkTraceRaysIndirectCommandKHR(Allocator* alloc, VkStructureType rootType,
                                            const VkTraceRaysIndirectCommandKHR* from,
                                            VkTraceRaysIndirectCommandKHR* to);

#endif
#ifdef VK_KHR_ray_query
void deepcopy_VkPhysicalDeviceRayQueryFeaturesKHR(Allocator* alloc, VkStructureType rootType,
                                                  const VkPhysicalDeviceRayQueryFeaturesKHR* from,
                                                  VkPhysicalDeviceRayQueryFeaturesKHR* to);

#endif
#ifdef VK_EXT_mesh_shader
void deepcopy_VkPhysicalDeviceMeshShaderFeaturesEXT(
    Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceMeshShaderFeaturesEXT* from,
    VkPhysicalDeviceMeshShaderFeaturesEXT* to);

void deepcopy_VkPhysicalDeviceMeshShaderPropertiesEXT(
    Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceMeshShaderPropertiesEXT* from,
    VkPhysicalDeviceMeshShaderPropertiesEXT* to);

void deepcopy_VkDrawMeshTasksIndirectCommandEXT(Allocator* alloc, VkStructureType rootType,
                                                const VkDrawMeshTasksIndirectCommandEXT* from,
                                                VkDrawMeshTasksIndirectCommandEXT* to);

#endif

}  // namespace vk
}  // namespace gfxstream